@budibase/server 1.0.123-alpha.0 → 1.0.123

package/src/api/controllers/table/{internal.ts → internal.js}

@@ -1,19 +1,40 @@
-import { updateLinks, EventType } from "../../../db/linkedRows"
-import { getRowParams, generateTableID } from "../../../db/utils"
-import { FieldTypes } from "../../../constants"
-import {
+const linkRows = require("../../../db/linkedRows")
+const { getRowParams, generateTableID } = require("../../../db/utils")
+const { FieldTypes } = require("../../../constants")
+const {
   TableSaveFunctions,
   hasTypeChanged,
   getTable,
   handleDataImport,
-} from "./utils"
+} = require("./utils")
+const usageQuota = require("../../../utilities/usageQuota")
 const { getAppDB } = require("@budibase/backend-core/context")
-import { isTest } from "../../../environment"
-import { cleanupAttachments } from "../../../utilities/rowProcessor"
-import { runStaticFormulaChecks } from "./bulkFormula"
-import { quotas, QuotaUsageType, StaticQuotaName } from "@budibase/pro"
+const env = require("../../../environment")
+const {
+  cleanupAttachments,
+  fixAutoColumnSubType,
+} = require("../../../utilities/rowProcessor")
+const { runStaticFormulaChecks } = require("./bulkFormula")
+
+function checkAutoColumns(table, oldTable) {
+  if (!table.schema) {
+    return table
+  }
+  for (let [key, schema] of Object.entries(table.schema)) {
+    if (!schema.autocolumn || schema.subtype) {
+      continue
+    }
+    const oldSchema = oldTable && oldTable.schema[key]
+    if (oldSchema && oldSchema.subtype) {
+      table.schema[key].subtype = oldSchema.subtype
+    } else {
+      table.schema[key] = fixAutoColumnSubType(schema)
+    }
+  }
+  return table
+}
 
-export async function save(ctx: any) {
+exports.save = async function (ctx) {
   const db = getAppDB()
   const { dataImport, ...rest } = ctx.request.body
   let tableToSave = {
@@ -29,9 +50,12 @@ export async function save(ctx: any) {
     oldTable = await db.get(ctx.request.body._id)
   }
 
+  // check all types are correct
   if (hasTypeChanged(tableToSave, oldTable)) {
     ctx.throw(400, "A column type has changed.")
   }
+  // check that subtypes have been maintained
+  tableToSave = checkAutoColumns(tableToSave, oldTable)
 
   // saving a table is a complex operation, involving many different steps, this
   // has been broken out into a utility to make it more obvious/easier to manipulate
@@ -80,8 +104,10 @@ export async function save(ctx: any) {
 
   // update linked rows
   try {
-    const linkResp: any = await updateLinks({
-      eventType: oldTable ? EventType.TABLE_UPDATED : EventType.TABLE_SAVE,
+    const linkResp = await linkRows.updateLinks({
+      eventType: oldTable
+        ? linkRows.EventType.TABLE_UPDATED
+        : linkRows.EventType.TABLE_SAVE,
       table: tableToSave,
       oldTable: oldTable,
     })
@@ -103,11 +129,11 @@ export async function save(ctx: any) {
 
   tableToSave = await tableSaveFunctions.after(tableToSave)
   // has to run after, make sure it has _id
-  await runStaticFormulaChecks(tableToSave, { oldTable, deletion: null })
+  await runStaticFormulaChecks(tableToSave, { oldTable })
   return tableToSave
 }
 
-export async function destroy(ctx: any) {
+exports.destroy = async function (ctx) {
   const db = getAppDB()
   const tableToDelete = await db.get(ctx.params.tableId)
 
@@ -117,14 +143,12 @@ export async function destroy(ctx: any) {
       include_docs: true,
     })
   )
-  await db.bulkDocs(
-    rows.rows.map((row: any) => ({ ...row.doc, _deleted: true }))
-  )
-  await quotas.removeRows(rows.rows.length)
+  await db.bulkDocs(rows.rows.map(row => ({ ...row.doc, _deleted: true })))
+  await usageQuota.update(usageQuota.Properties.ROW, -rows.rows.length)
 
   // update linked rows
-  await updateLinks({
-    eventType: EventType.TABLE_DELETE,
+  await linkRows.updateLinks({
+    eventType: linkRows.EventType.TABLE_DELETE,
     table: tableToDelete,
   })
 
@@ -132,10 +156,10 @@ export async function destroy(ctx: any) {
   await db.remove(tableToDelete)
 
   // remove table search index
-  if (!isTest()) {
+  if (!env.isTest()) {
     const currentIndexes = await db.getIndexes()
     const existingIndex = currentIndexes.indexes.find(
-      (existing: any) => existing.name === `search:${ctx.params.tableId}`
+      existing => existing.name === `search:${ctx.params.tableId}`
     )
     if (existingIndex) {
       await db.deleteIndex(existingIndex)
@@ -143,15 +167,12 @@ export async function destroy(ctx: any) {
   }
 
   // has to run after, make sure it has _id
-  await runStaticFormulaChecks(tableToDelete, {
-    oldTable: null,
-    deletion: true,
-  })
+  await runStaticFormulaChecks(tableToDelete, { deletion: true })
   await cleanupAttachments(tableToDelete, { rows })
   return tableToDelete
 }
 
-export async function bulkImport(ctx: any) {
+exports.bulkImport = async function (ctx) {
   const table = await getTable(ctx.params.tableId)
   const { dataImport } = ctx.request.body
   await handleDataImport(ctx.user, table, dataImport)

package/src/api/controllers/table/{utils.ts → utils.js}

@@ -1,34 +1,34 @@
-import { transform } from "../../../utilities/csvParser"
-import {
+const csvParser = require("../../../utilities/csvParser")
+const {
   getRowParams,
   generateRowID,
   InternalTables,
   getTableParams,
   BudibaseInternalDB,
-} from "../../../db/utils"
-import { isEqual } from "lodash"
-import { AutoFieldSubTypes, FieldTypes } from "../../../constants"
-import {
+} = require("../../../db/utils")
+const { isEqual } = require("lodash")
+const { AutoFieldSubTypes, FieldTypes } = require("../../../constants")
+const {
   inputProcessing,
   cleanupAttachments,
-} from "../../../utilities/rowProcessor"
-import {
+} = require("../../../utilities/rowProcessor")
+const {
   USERS_TABLE_SCHEMA,
   SwitchableTypes,
   CanSwitchTypes,
-} from "../../../constants"
-import {
+} = require("../../../constants")
+const {
   isExternalTable,
   breakExternalTableId,
   isSQL,
-} from "../../../integrations/utils"
-import { getViews, saveView } from "../view/utils"
-import viewTemplate from "../view/viewBuilder"
+} = require("../../../integrations/utils")
+const { getViews, saveView } = require("../view/utils")
+const viewTemplate = require("../view/viewBuilder")
+const usageQuota = require("../../../utilities/usageQuota")
 const { getAppDB } = require("@budibase/backend-core/context")
-import { cloneDeep } from "lodash/fp"
-import { quotas, QuotaUsageType, StaticQuotaName } from "@budibase/pro"
+const { cloneDeep } = require("lodash/fp")
 
-export async function clearColumns(table: any, columnNames: any) {
+exports.clearColumns = async (table, columnNames) => {
   const db = getAppDB()
   const rows = await db.allDocs(
     getRowParams(table._id, null, {
@@ -36,18 +36,18 @@ export async function clearColumns(table: any, columnNames: any) {
     })
   )
   return db.bulkDocs(
-    rows.rows.map(({ doc }: any) => {
-      columnNames.forEach((colName: any) => delete doc[colName])
+    rows.rows.map(({ doc }) => {
+      columnNames.forEach(colName => delete doc[colName])
       return doc
     })
   )
 }
 
-export async function checkForColumnUpdates(oldTable: any, updatedTable: any) {
+exports.checkForColumnUpdates = async (oldTable, updatedTable) => {
   const db = getAppDB()
   let updatedRows = []
   const rename = updatedTable._rename
-  let deletedColumns: any = []
+  let deletedColumns = []
   if (oldTable && oldTable.schema && updatedTable.schema) {
     deletedColumns = Object.keys(oldTable.schema).filter(
       colName => updatedTable.schema[colName] == null
@@ -61,14 +61,14 @@ export async function checkForColumnUpdates(oldTable: any, updatedTable: any) {
         include_docs: true,
       })
     )
-    const rawRows = rows.rows.map(({ doc }: any) => doc)
-    updatedRows = rawRows.map((row: any) => {
+    const rawRows = rows.rows.map(({ doc }) => doc)
+    updatedRows = rawRows.map(row => {
       row = cloneDeep(row)
       if (rename) {
         row[rename.updated] = row[rename.old]
         delete row[rename.old]
       } else if (deletedColumns.length !== 0) {
-        deletedColumns.forEach((colName: any) => delete row[colName])
+        deletedColumns.forEach(colName => delete row[colName])
       }
       return row
     })
@@ -76,14 +76,14 @@ export async function checkForColumnUpdates(oldTable: any, updatedTable: any) {
     // cleanup any attachments from object storage for deleted attachment columns
     await cleanupAttachments(updatedTable, { oldTable, rows: rawRows })
     // Update views
-    await checkForViewUpdates(updatedTable, rename, deletedColumns)
+    await exports.checkForViewUpdates(updatedTable, rename, deletedColumns)
     delete updatedTable._rename
   }
   return { rows: updatedRows, table: updatedTable }
 }
 
 // makes sure the passed in table isn't going to reset the auto ID
-export function makeSureTableUpToDate(table: any, tableToSave: any) {
+exports.makeSureTableUpToDate = (table, tableToSave) => {
   if (!table) {
     return tableToSave
   }
@@ -91,9 +91,7 @@ export function makeSureTableUpToDate(table: any, tableToSave: any) {
   tableToSave._rev = table._rev
   // make sure auto IDs are always updated - these are internal
   // so the client may not know they have changed
-  let field: any
-  let column: any
-  for ([field, column] of Object.entries(table.schema)) {
+  for (let [field, column] of Object.entries(table.schema)) {
     if (
       column.autocolumn &&
       column.subtype === AutoFieldSubTypes.AUTO_ID &&
@@ -105,32 +103,30 @@ export function makeSureTableUpToDate(table: any, tableToSave: any) {
   return tableToSave
 }
 
-export async function handleDataImport(user: any, table: any, dataImport: any) {
+exports.handleDataImport = async (user, table, dataImport) => {
   if (!dataImport || !dataImport.csvString) {
     return table
   }
 
   const db = getAppDB()
   // Populate the table with rows imported from CSV in a bulk update
-  const data = await transform({
+  const data = await csvParser.transform({
     ...dataImport,
     existingTable: table,
   })
 
-  let finalData: any = []
+  let finalData = []
   for (let i = 0; i < data.length; i++) {
     let row = data[i]
     row._id = generateRowID(table._id)
     row.tableId = table._id
-    const processed: any = inputProcessing(user, table, row, {
+    const processed = inputProcessing(user, table, row, {
       noAutoRelationships: true,
     })
     table = processed.table
     row = processed.row
 
-    let fieldName: any
-    let schema: any
-    for ([fieldName, schema] of Object.entries(table.schema)) {
+    for (let [fieldName, schema] of Object.entries(table.schema)) {
       // check whether the options need to be updated for inclusion as part of the data import
       if (
         schema.type === FieldTypes.OPTIONS &&
@@ -147,13 +143,17 @@ export async function handleDataImport(user: any, table: any, dataImport: any) {
     finalData.push(row)
   }
 
-  await quotas.addRows(finalData.length, () => db.bulkDocs(finalData))
+  await usageQuota.update(usageQuota.Properties.ROW, finalData.length, {
+    dryRun: true,
+  })
+  await db.bulkDocs(finalData)
+  await usageQuota.update(usageQuota.Properties.ROW, finalData.length)
   let response = await db.put(table)
   table._rev = response._rev
   return table
 }
 
-export async function handleSearchIndexes(table: any) {
+exports.handleSearchIndexes = async table => {
   const db = getAppDB()
   // create relevant search indexes
   if (table.indexes && table.indexes.length > 0) {
@@ -161,12 +161,12 @@ export async function handleSearchIndexes(table: any) {
     const indexName = `search:${table._id}`
 
     const existingIndex = currentIndexes.indexes.find(
-      (existing: any) => existing.name === indexName
+      existing => existing.name === indexName
     )
 
     if (existingIndex) {
       const currentFields = existingIndex.def.fields.map(
-        (field: any) => Object.keys(field)[0]
+        field => Object.keys(field)[0]
       )
 
       // if index fields have changed, delete the original index
@@ -197,7 +197,7 @@ export async function handleSearchIndexes(table: any) {
   return table
 }
 
-export function checkStaticTables(table: any) {
+exports.checkStaticTables = table => {
   // check user schema has all required elements
   if (table._id === InternalTables.USER_METADATA) {
     for (let [key, schema] of Object.entries(USERS_TABLE_SCHEMA.schema)) {
@@ -211,13 +211,7 @@ export function checkStaticTables(table: any) {
 }
 
 class TableSaveFunctions {
-  db: any
-  user: any
-  oldTable: any
-  dataImport: any
-  rows: any
-
-  constructor({ user, oldTable, dataImport }: any) {
+  constructor({ user, oldTable, dataImport }) {
     this.db = getAppDB()
     this.user = user
     this.oldTable = oldTable
@@ -227,25 +221,25 @@ class TableSaveFunctions {
   }
 
   // before anything is done
-  async before(table: any) {
+  async before(table) {
     if (this.oldTable) {
-      table = makeSureTableUpToDate(this.oldTable, table)
+      table = exports.makeSureTableUpToDate(this.oldTable, table)
     }
-    table = checkStaticTables(table)
+    table = exports.checkStaticTables(table)
     return table
   }
 
   // when confirmed valid
-  async mid(table: any) {
-    let response = await checkForColumnUpdates(this.oldTable, table)
+  async mid(table) {
+    let response = await exports.checkForColumnUpdates(this.oldTable, table)
     this.rows = this.rows.concat(response.rows)
     return table
   }
 
   // after saving
-  async after(table: any) {
-    table = await handleSearchIndexes(table)
-    table = await handleDataImport(this.user, table, this.dataImport)
+  async after(table) {
+    table = await exports.handleSearchIndexes(table)
+    table = await exports.handleDataImport(this.user, table, this.dataImport)
     return table
   }
 
@@ -254,21 +248,21 @@ class TableSaveFunctions {
   }
 }
 
-export async function getAllInternalTables() {
+exports.getAllInternalTables = async () => {
   const db = getAppDB()
   const internalTables = await db.allDocs(
     getTableParams(null, {
       include_docs: true,
     })
   )
-  return internalTables.rows.map((tableDoc: any) => ({
+  return internalTables.rows.map(tableDoc => ({
     ...tableDoc.doc,
     type: "internal",
     sourceId: BudibaseInternalDB._id,
   }))
 }
 
-export async function getAllExternalTables(datasourceId: any) {
+exports.getAllExternalTables = async datasourceId => {
   const db = getAppDB()
   const datasource = await db.get(datasourceId)
   if (!datasource || !datasource.entities) {
@@ -277,28 +271,24 @@ export async function getAllExternalTables(datasourceId: any) {
   return datasource.entities
 }
 
-export async function getExternalTable(datasourceId: any, tableName: any) {
-  const entities = await getAllExternalTables(datasourceId)
+exports.getExternalTable = async (datasourceId, tableName) => {
+  const entities = await exports.getAllExternalTables(datasourceId)
   return entities[tableName]
 }
 
-export async function getTable(tableId: any) {
+exports.getTable = async tableId => {
   const db = getAppDB()
   if (isExternalTable(tableId)) {
     let { datasourceId, tableName } = breakExternalTableId(tableId)
     const datasource = await db.get(datasourceId)
-    const table = await getExternalTable(datasourceId, tableName)
+    const table = await exports.getExternalTable(datasourceId, tableName)
     return { ...table, sql: isSQL(datasource) }
   } else {
     return db.get(tableId)
   }
 }
 
-export async function checkForViewUpdates(
-  table: any,
-  rename: any,
-  deletedColumns: any
-) {
+exports.checkForViewUpdates = async (table, rename, deletedColumns) => {
   const views = await getViews()
   const tableViews = views.filter(view => view.meta.tableId === table._id)
 
@@ -322,7 +312,7 @@ export async function checkForViewUpdates(
 
       // Update filters if required
       if (view.meta.filters) {
-        view.meta.filters.forEach((filter: any) => {
+        view.meta.filters.forEach(filter => {
           if (filter.key === rename.old) {
             filter.key = rename.updated
             needsUpdated = true
@@ -330,7 +320,7 @@ export async function checkForViewUpdates(
         })
       }
     } else if (deletedColumns) {
-      deletedColumns.forEach((column: any) => {
+      deletedColumns.forEach(column => {
         // Remove calculation statement if required
         if (view.meta.field === column) {
           delete view.meta.field
@@ -348,7 +338,7 @@ export async function checkForViewUpdates(
         // Remove filters referencing deleted field if required
         if (view.meta.filters && view.meta.filters.length) {
           const initialLength = view.meta.filters.length
-          view.meta.filters = view.meta.filters.filter((filter: any) => {
+          view.meta.filters = view.meta.filters.filter(filter => {
             return filter.key !== column
           })
           if (initialLength !== view.meta.filters.length) {
@@ -370,20 +360,16 @@ export async function checkForViewUpdates(
   }
 }
 
-export function generateForeignKey(column: any, relatedTable: any) {
+exports.generateForeignKey = (column, relatedTable) => {
   return `fk_${relatedTable.name}_${column.fieldName}`
 }
 
-export function generateJunctionTableName(
-  column: any,
-  table: any,
-  relatedTable: any
-) {
+exports.generateJunctionTableName = (column, table, relatedTable) => {
   return `jt_${table.name}_${relatedTable.name}_${column.name}_${column.fieldName}`
 }
 
-export function foreignKeyStructure(keyName: any, meta = null) {
-  const structure: any = {
+exports.foreignKeyStructure = (keyName, meta = null) => {
+  const structure = {
     type: FieldTypes.NUMBER,
     constraints: {},
     name: keyName,
@@ -394,7 +380,7 @@ export function foreignKeyStructure(keyName: any, meta = null) {
   return structure
 }
 
-export function areSwitchableTypes(type1: any, type2: any) {
+exports.areSwitchableTypes = (type1, type2) => {
   if (
     SwitchableTypes.indexOf(type1) === -1 &&
     SwitchableTypes.indexOf(type2) === -1
@@ -411,24 +397,21 @@ export function areSwitchableTypes(type1: any, type2: any) {
   return false
 }
 
-export function hasTypeChanged(table: any, oldTable: any) {
+exports.hasTypeChanged = (table, oldTable) => {
   if (!oldTable) {
     return false
   }
-  let key: any
-  let field: any
-  for ([key, field] of Object.entries(oldTable.schema)) {
+  for (let [key, field] of Object.entries(oldTable.schema)) {
     const oldType = field.type
     if (!table.schema[key]) {
       continue
     }
     const newType = table.schema[key].type
-    if (oldType !== newType && !areSwitchableTypes(oldType, newType)) {
+    if (oldType !== newType && !exports.areSwitchableTypes(oldType, newType)) {
       return true
     }
   }
   return false
 }
 
-const _TableSaveFunctions = TableSaveFunctions
-export { _TableSaveFunctions as TableSaveFunctions }
+exports.TableSaveFunctions = TableSaveFunctions

package/src/api/index.js

@@ -4,14 +4,12 @@ const {
   auditLog,
   buildTenancyMiddleware,
 } = require("@budibase/backend-core/auth")
-const { errors } = require("@budibase/backend-core")
 const currentApp = require("../middleware/currentapp")
 const compress = require("koa-compress")
 const zlib = require("zlib")
 const { mainRoutes, staticRoutes, publicRoutes } = require("./routes")
 const pkg = require("../../package.json")
 const env = require("../environment")
-const { middleware: pro } = require("@budibase/pro")
 
 const router = new Router()
 
@@ -54,7 +52,6 @@ router
     })
   )
   .use(currentApp)
-  .use(pro.licensing())
   .use(auditLog)
 
 // error handling middleware
@@ -63,12 +60,10 @@ router.use(async (ctx, next) => {
     await next()
   } catch (err) {
     ctx.status = err.status || err.statusCode || 500
-    const error = errors.getPublicError(err)
     ctx.body = {
       message: err.message,
       status: ctx.status,
       validationErrors: err.validation,
-      error,
     }
     if (env.NODE_ENV !== "jest") {
       ctx.log.error(err)

package/src/api/routes/{application.ts → application.js}

@@ -1,13 +1,14 @@
-import Router from "@koa/router"
-import * as controller from "../controllers/application"
-import authorized from "../../middleware/authorized"
-import { BUILDER } from "@budibase/backend-core/permissions"
+const Router = require("@koa/router")
+const controller = require("../controllers/application")
+const authorized = require("../../middleware/authorized")
+const { BUILDER } = require("@budibase/backend-core/permissions")
+const usage = require("../../middleware/usageQuota")
 
-const router = new Router()
+const router = Router()
 
 router
   .post("/api/applications/:appId/sync", authorized(BUILDER), controller.sync)
-  .post("/api/applications", authorized(BUILDER), controller.create)
+  .post("/api/applications", authorized(BUILDER), usage, controller.create)
   .get("/api/applications/:appId/definition", controller.fetchAppDefinition)
   .get("/api/applications", controller.fetch)
   .get("/api/applications/:appId/appPackage", controller.fetchAppPackage)
@@ -22,6 +23,11 @@ router
     authorized(BUILDER),
     controller.revertClient
   )
-  .delete("/api/applications/:appId", authorized(BUILDER), controller.destroy)
+  .delete(
+    "/api/applications/:appId",
+    authorized(BUILDER),
+    usage,
+    controller.delete
+  )
 
-export default router
+module.exports = router

package/src/api/routes/index.js

@@ -0,0 +1,62 @@
+const authRoutes = require("./auth")
+const layoutRoutes = require("./layout")
+const screenRoutes = require("./screen")
+const userRoutes = require("./user")
+const applicationRoutes = require("./application")
+const tableRoutes = require("./table")
+const rowRoutes = require("./row")
+const viewRoutes = require("./view")
+const staticRoutes = require("./static")
+const componentRoutes = require("./component")
+const automationRoutes = require("./automation")
+const webhookRoutes = require("./webhook")
+const roleRoutes = require("./role")
+const deployRoutes = require("./deploy")
+const apiKeysRoutes = require("./apikeys")
+const templatesRoutes = require("./templates")
+const analyticsRoutes = require("./analytics")
+const routingRoutes = require("./routing")
+const integrationRoutes = require("./integration")
+const permissionRoutes = require("./permission")
+const datasourceRoutes = require("./datasource")
+const queryRoutes = require("./query")
+const backupRoutes = require("./backup")
+const metadataRoutes = require("./metadata")
+const devRoutes = require("./dev")
+const cloudRoutes = require("./cloud")
+const migrationRoutes = require("./migrations")
+const publicRoutes = require("./public")
+
+exports.mainRoutes = [
+  authRoutes,
+  deployRoutes,
+  layoutRoutes,
+  screenRoutes,
+  userRoutes,
+  applicationRoutes,
+  automationRoutes,
+  viewRoutes,
+  componentRoutes,
+  roleRoutes,
+  apiKeysRoutes,
+  templatesRoutes,
+  analyticsRoutes,
+  webhookRoutes,
+  routingRoutes,
+  integrationRoutes,
+  permissionRoutes,
+  datasourceRoutes,
+  queryRoutes,
+  backupRoutes,
+  metadataRoutes,
+  devRoutes,
+  cloudRoutes,
+  // these need to be handled last as they still use /api/:tableId
+  // this could be breaking as koa may recognise other routes as this
+  tableRoutes,
+  rowRoutes,
+  migrationRoutes,
+]
+
+exports.publicRoutes = publicRoutes
+exports.staticRoutes = staticRoutes