@budibase/server 2.1.43-alpha.2 → 2.1.43

package/src/api/controllers/static/index.ts

@@ -14,14 +14,19 @@ const {
 } = require("../../../utilities/fileSystem")
 const env = require("../../../environment")
 const { clientLibraryPath } = require("../../../utilities")
+const { upload, deleteFiles } = require("../../../utilities/fileSystem")
 const { attachmentsRelativeURL } = require("../../../utilities")
 const { DocumentType } = require("../../../db/utils")
-const { context, objectStore, utils } = require("@budibase/backend-core")
+const { getAppDB, getAppId } = require("@budibase/backend-core/context")
+const { setCookie, clearCookie } = require("@budibase/backend-core/utils")
 const AWS = require("aws-sdk")
 const fs = require("fs")
+const {
+  downloadTarballDirect,
+} = require("../../../utilities/fileSystem/utilities")
 
 async function prepareUpload({ s3Key, bucket, metadata, file }: any) {
-  const response = await objectStore.upload({
+  const response = await upload({
     bucket,
     metadata,
     filename: s3Key,
@@ -43,7 +48,7 @@ export const toggleBetaUiFeature = async function (ctx: any) {
   const cookieName = `beta:${ctx.params.feature}`
 
   if (ctx.cookies.get(cookieName)) {
-    utils.clearCookie(ctx, cookieName)
+    clearCookie(ctx, cookieName)
     ctx.body = {
       message: `${ctx.params.feature} disabled`,
     }
@@ -56,11 +61,11 @@ export const toggleBetaUiFeature = async function (ctx: any) {
   if (!fs.existsSync(builderPath)) {
     fs.mkdirSync(builderPath)
   }
-  await objectStore.downloadTarballDirect(
+  await downloadTarballDirect(
     "https://cdn.budi.live/beta:design_ui/new_ui.tar.gz",
     builderPath
   )
-  utils.setCookie(ctx, {}, cookieName)
+  setCookie(ctx, {}, cookieName)
 
   ctx.body = {
     message: `${ctx.params.feature} enabled`,
@@ -94,16 +99,13 @@ export const uploadFile = async function (ctx: any) {
 }
 
 export const deleteObjects = async function (ctx: any) {
-  ctx.body = await objectStore.deleteFiles(
-    ObjectStoreBuckets.APPS,
-    ctx.request.body.keys
-  )
+  ctx.body = await deleteFiles(ObjectStoreBuckets.APPS, ctx.request.body.keys)
 }
 
 export const serveApp = async function (ctx: any) {
-  const db = context.getAppDB({ skip_setup: true })
+  const db = getAppDB({ skip_setup: true })
   const appInfo = await db.get(DocumentType.APP_METADATA)
-  let appId = context.getAppId()
+  let appId = getAppId()
 
   if (!env.isJest()) {
     const App = require("./templates/BudibaseApp.svelte").default
@@ -132,11 +134,11 @@ export const serveApp = async function (ctx: any) {
 }
 
 export const serveBuilderPreview = async function (ctx: any) {
-  const db = context.getAppDB({ skip_setup: true })
+  const db = getAppDB({ skip_setup: true })
   const appInfo = await db.get(DocumentType.APP_METADATA)
 
   if (!env.isJest()) {
-    let appId = context.getAppId()
+    let appId = getAppId()
     const previewHbs = loadHandlebarsFile(`${__dirname}/templates/preview.hbs`)
     ctx.body = await processString(previewHbs, {
       clientLibPath: clientLibraryPath(appId, appInfo.version, ctx),
@@ -154,7 +156,7 @@ export const serveClientLibrary = async function (ctx: any) {
 }
 
 export const getSignedUploadURL = async function (ctx: any) {
-  const database = context.getAppDB()
+  const database = getAppDB()
 
   // Ensure datasource is valid
   let datasource

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

@@ -1,14 +1,13 @@
-import { FieldTypes, FormulaTypes } from "../../../constants"
-import { clearColumns } from "./utils"
-import { doesContainStrings } from "@budibase/string-templates"
-import { cloneDeep } from "lodash/fp"
-import { isEqual, uniq } from "lodash"
-import { updateAllFormulasInTable } from "../row/staticFormula"
-import { context } from "@budibase/backend-core"
-import { FieldSchema, Table } from "@budibase/types"
-import sdk from "../../../sdk"
+const { FieldTypes, FormulaTypes } = require("../../../constants")
+const { clearColumns } = require("./utils")
+const { doesContainStrings } = require("@budibase/string-templates")
+const { cloneDeep } = require("lodash/fp")
+const { isEqual, uniq } = require("lodash")
+const { updateAllFormulasInTable } = require("../row/staticFormula")
+const { getAppDB } = require("@budibase/backend-core/context")
+const sdk = require("../../../sdk")
 
-function isStaticFormula(column: FieldSchema) {
+function isStaticFormula(column) {
   return (
     column.type === FieldTypes.FORMULA &&
     column.formulaType === FormulaTypes.STATIC
@@ -19,8 +18,8 @@ function isStaticFormula(column: FieldSchema) {
  * This retrieves the formula columns from a table schema that use a specified column name
  * in the formula.
  */
-function getFormulaThatUseColumn(table: Table, columnNames: string[] | string) {
-  let formula: string[] = []
+function getFormulaThatUseColumn(table, columnNames) {
+  let formula = []
   columnNames = Array.isArray(columnNames) ? columnNames : [columnNames]
   for (let column of Object.values(table.schema)) {
     // not a static formula, or doesn't contain a relationship
@@ -39,10 +38,7 @@ function getFormulaThatUseColumn(table: Table, columnNames: string[] | string) {
  * This functions checks for when a related table, column or related column is deleted, if any
  * tables need to have the formula column removed.
  */
-async function checkIfFormulaNeedsCleared(
-  table: Table,
-  { oldTable, deletion }: { oldTable?: Table; deletion?: boolean }
-) {
+async function checkIfFormulaNeedsCleared(table, { oldTable, deletion }) {
   // start by retrieving all tables, remove the current table from the list
   const tables = (await sdk.tables.getAllInternalTables()).filter(
     tbl => tbl._id !== table._id
@@ -53,14 +49,11 @@ async function checkIfFormulaNeedsCleared(
   )
   // remove any formula columns that used related columns
   for (let removed of removedColumns) {
-    let tableToUse: Table | undefined = table
+    let tableToUse = table
     // if relationship, get the related table
     if (removed.type === FieldTypes.LINK) {
       tableToUse = tables.find(table => table._id === removed.tableId)
     }
-    if (!tableToUse) {
-      continue
-    }
     const columnsToDelete = getFormulaThatUseColumn(tableToUse, removed.name)
     if (columnsToDelete.length > 0) {
       await clearColumns(table, columnsToDelete)
@@ -78,11 +71,11 @@ async function checkIfFormulaNeedsCleared(
       // look to see if the column was used in a relationship formula,
       // relationships won't be used for this
       if (relatedTable && relatedColumns && removed.type !== FieldTypes.LINK) {
-        let relatedFormulaToRemove: string[] = []
+        let relatedFormulaToRemove = []
         for (let column of relatedColumns) {
           relatedFormulaToRemove = relatedFormulaToRemove.concat(
             getFormulaThatUseColumn(relatedTable, [
-              column.fieldName!,
+              column.fieldName,
               removed.name,
             ])
           )
@@ -102,14 +95,13 @@ async function checkIfFormulaNeedsCleared(
  * specifically only for static formula.
  */
 async function updateRelatedFormulaLinksOnTables(
-  table: Table,
-  { deletion }: { deletion?: boolean } = {}
+  table,
+  { deletion } = { deletion: false }
 ) {
-  const tableId: string = table._id!
-  const db = context.getAppDB()
+  const db = getAppDB()
   // start by retrieving all tables, remove the current table from the list
   const tables = (await sdk.tables.getAllInternalTables()).filter(
-    tbl => tbl._id !== tableId
+    tbl => tbl._id !== table._id
   )
   // clone the tables, so we can compare at end
   const initialTables = cloneDeep(tables)
@@ -122,7 +114,7 @@ async function updateRelatedFormulaLinksOnTables(
     if (!otherTable.relatedFormula) {
       continue
     }
-    const index = otherTable.relatedFormula.indexOf(tableId)
+    const index = otherTable.relatedFormula.indexOf(table._id)
     if (index !== -1) {
       otherTable.relatedFormula.splice(index, 1)
     }
@@ -141,11 +133,11 @@ async function updateRelatedFormulaLinksOnTables(
       if (
         relatedTable &&
         (!relatedTable.relatedFormula ||
-          !relatedTable.relatedFormula.includes(tableId))
+          !relatedTable.relatedFormula.includes(table._id))
       ) {
         relatedTable.relatedFormula = relatedTable.relatedFormula
-          ? [...relatedTable.relatedFormula, tableId]
-          : [tableId]
+          ? [...relatedTable.relatedFormula, table._id]
+          : [table._id]
       }
     }
   }
@@ -158,10 +150,7 @@ async function updateRelatedFormulaLinksOnTables(
   }
 }
 
-async function checkIfFormulaUpdated(
-  table: Table,
-  { oldTable }: { oldTable?: Table }
-) {
+async function checkIfFormulaUpdated(table, { oldTable }) {
   // look to see if any formula values have changed
   const shouldUpdate = Object.values(table.schema).find(
     column =>
@@ -176,10 +165,7 @@ async function checkIfFormulaUpdated(
   }
 }
 
-export async function runStaticFormulaChecks(
-  table: Table,
-  { oldTable, deletion }: { oldTable?: Table; deletion?: boolean }
-) {
+exports.runStaticFormulaChecks = async (table, { oldTable, deletion }) => {
   await updateRelatedFormulaLinksOnTables(table, { deletion })
   await checkIfFormulaNeedsCleared(table, { oldTable, deletion })
   if (!deletion) {

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

@@ -1,43 +1,38 @@
-import {
+const {
   buildExternalTableId,
   breakExternalTableId,
-} from "../../../integrations/utils"
-import {
+} = require("../../../integrations/utils")
+const {
   generateForeignKey,
   generateJunctionTableName,
   foreignKeyStructure,
   hasTypeChanged,
-} from "./utils"
-import { FieldTypes, RelationshipTypes } from "../../../constants"
-import { makeExternalQuery } from "../../../integrations/base/query"
-import * as csvParser from "../../../utilities/csvParser"
-import { handleRequest } from "../row/external"
-import { events, context } from "@budibase/backend-core"
-import {
-  Datasource,
-  Table,
-  QueryJson,
-  Operation,
-  RenameColumn,
-  FieldSchema,
-  BBContext,
-  TableRequest,
-} from "@budibase/types"
-import sdk from "../../../sdk"
+} = require("./utils")
+const {
+  DataSourceOperation,
+  FieldTypes,
+  RelationshipTypes,
+} = require("../../../constants")
+const { makeExternalQuery } = require("../../../integrations/base/query")
 const { cloneDeep } = require("lodash/fp")
+const csvParser = require("../../../utilities/csvParser")
+const { handleRequest } = require("../row/external")
+const { getAppDB } = require("@budibase/backend-core/context")
+const { events } = require("@budibase/backend-core")
+const sdk = require("../../../sdk")
 
 async function makeTableRequest(
-  datasource: Datasource,
-  operation: Operation,
-  table: Table,
-  tables: Record<string, Table>,
-  oldTable?: Table,
-  renamed?: RenameColumn
+  datasource,
+  operation,
+  table,
+  tables,
+  oldTable = null,
+  renamed = null
 ) {
-  const json: QueryJson = {
+  const json = {
     endpoint: {
-      datasourceId: datasource._id!,
-      entityId: table._id!,
+      datasourceId: datasource._id,
+      entityId: table._id,
       operation,
     },
     meta: {
@@ -46,19 +41,15 @@ async function makeTableRequest(
     table,
   }
   if (oldTable) {
-    json.meta!.table = oldTable
+    json.meta.table = oldTable
   }
   if (renamed) {
-    json.meta!.renamed = renamed
+    json.meta.renamed = renamed
   }
   return makeExternalQuery(datasource, json)
 }
 
-function cleanupRelationships(
-  table: Table,
-  tables: Record<string, Table>,
-  oldTable?: Table
-) {
+function cleanupRelationships(table, tables, oldTable = null) {
   const tableToIterate = oldTable ? oldTable : table
   // clean up relationships in couch table schemas
   for (let [key, schema] of Object.entries(tableToIterate.schema)) {
@@ -87,7 +78,7 @@ function cleanupRelationships(
   }
 }
 
-function getDatasourceId(table: Table) {
+function getDatasourceId(table) {
   if (!table) {
     throw "No table supplied"
   }
@@ -97,7 +88,7 @@ function getDatasourceId(table: Table) {
   return breakExternalTableId(table._id).datasourceId
 }
 
-function otherRelationshipType(type?: string) {
+function otherRelationshipType(type) {
   if (type === RelationshipTypes.MANY_TO_MANY) {
     return RelationshipTypes.MANY_TO_MANY
   }
@@ -106,21 +97,13 @@ function otherRelationshipType(type?: string) {
     : RelationshipTypes.ONE_TO_MANY
 }
 
-function generateManyLinkSchema(
-  datasource: Datasource,
-  column: FieldSchema,
-  table: Table,
-  relatedTable: Table
-): Table {
-  if (!table.primary || !relatedTable.primary) {
-    throw new Error("Unable to generate many link schema, no primary keys")
-  }
+function generateManyLinkSchema(datasource, column, table, relatedTable) {
   const primary = table.name + table.primary[0]
   const relatedPrimary = relatedTable.name + relatedTable.primary[0]
   const jcTblName = generateJunctionTableName(column, table, relatedTable)
   // first create the new table
   const junctionTable = {
-    _id: buildExternalTableId(datasource._id!, jcTblName),
+    _id: buildExternalTableId(datasource._id, jcTblName),
     name: jcTblName,
     primary: [primary, relatedPrimary],
     constrained: [primary, relatedPrimary],
@@ -142,15 +125,7 @@ function generateManyLinkSchema(
   return junctionTable
 }
 
-function generateLinkSchema(
-  column: FieldSchema,
-  table: Table,
-  relatedTable: Table,
-  type: string
-) {
-  if (!table.primary || !relatedTable.primary) {
-    throw new Error("Unable to generate link schema, no primary keys")
-  }
+function generateLinkSchema(column, table, relatedTable, type) {
   const isOneSide = type === RelationshipTypes.ONE_TO_MANY
   const primary = isOneSide ? relatedTable.primary[0] : table.primary[0]
   // generate a foreign key
@@ -161,12 +136,7 @@ function generateLinkSchema(
   return foreignKey
 }
 
-function generateRelatedSchema(
-  linkColumn: FieldSchema,
-  table: Table,
-  relatedTable: Table,
-  columnName: string
-) {
+function generateRelatedSchema(linkColumn, table, relatedTable, columnName) {
   // generate column for other table
   const relatedSchema = cloneDeep(linkColumn)
   // swap them from the main link
@@ -189,21 +159,21 @@ function generateRelatedSchema(
   table.schema[columnName] = relatedSchema
 }
 
-function isRelationshipSetup(column: FieldSchema) {
+function isRelationshipSetup(column) {
   return column.foreignKey || column.through
 }
 
-export async function save(ctx: BBContext) {
-  const table: TableRequest = ctx.request.body
-  const renamed = table?._rename
+exports.save = async function (ctx) {
+  const table = ctx.request.body
+  const { _rename: renamed } = table
   // can't do this right now
   delete table.dataImport
-  const datasourceId = getDatasourceId(ctx.request.body)!
+  const datasourceId = getDatasourceId(ctx.request.body)
   // table doesn't exist already, note that it is created
   if (!table._id) {
     table.created = true
   }
-  let tableToSave: TableRequest = {
+  let tableToSave = {
     type: "table",
     _id: buildExternalTableId(datasourceId, table.name),
     ...table,
@@ -218,13 +188,13 @@ export async function save(ctx: BBContext) {
     ctx.throw(400, "A column type has changed.")
   }
 
-  const db = context.getAppDB()
+  const db = getAppDB()
   const datasource = await db.get(datasourceId)
   if (!datasource.entities) {
     datasource.entities = {}
   }
   const oldTables = cloneDeep(datasource.entities)
-  const tables: Record<string, Table> = datasource.entities
+  const tables = datasource.entities
 
   const extraTablesToUpdate = []
 
@@ -236,11 +206,8 @@ export async function save(ctx: BBContext) {
     const relatedTable = Object.values(tables).find(
       table => table._id === schema.tableId
     )
-    if (!relatedTable) {
-      continue
-    }
-    const relatedColumnName = schema.fieldName!
-    const relationType = schema.relationshipType!
+    const relatedColumnName = schema.fieldName
+    const relationType = schema.relationshipType
     if (relationType === RelationshipTypes.MANY_TO_MANY) {
       const junctionTable = generateManyLinkSchema(
         datasource,
@@ -280,7 +247,9 @@ export async function save(ctx: BBContext) {
 
   cleanupRelationships(tableToSave, tables, oldTable)
 
-  const operation = oldTable ? Operation.UPDATE_TABLE : Operation.CREATE_TABLE
+  const operation = oldTable
+    ? DataSourceOperation.UPDATE_TABLE
+    : DataSourceOperation.CREATE_TABLE
   await makeTableRequest(
     datasource,
     operation,
@@ -292,7 +261,9 @@ export async function save(ctx: BBContext) {
   // update any extra tables (like foreign keys in other tables)
   for (let extraTable of extraTablesToUpdate) {
     const oldExtraTable = oldTables[extraTable.name]
-    let op = oldExtraTable ? Operation.UPDATE_TABLE : Operation.CREATE_TABLE
+    let op = oldExtraTable
+      ? DataSourceOperation.UPDATE_TABLE
+      : DataSourceOperation.CREATE_TABLE
     await makeTableRequest(datasource, op, extraTable, tables, oldExtraTable)
   }
 
@@ -312,20 +283,18 @@ export async function save(ctx: BBContext) {
   return tableToSave
 }
 
-export async function destroy(ctx: BBContext) {
-  const tableToDelete: TableRequest = await sdk.tables.getTable(
-    ctx.params.tableId
-  )
+exports.destroy = async function (ctx) {
+  const tableToDelete = await sdk.tables.getTable(ctx.params.tableId)
   if (!tableToDelete || !tableToDelete.created) {
     ctx.throw(400, "Cannot delete tables which weren't created in Budibase.")
   }
   const datasourceId = getDatasourceId(tableToDelete)
 
-  const db = context.getAppDB()
+  const db = getAppDB()
   const datasource = await db.get(datasourceId)
   const tables = datasource.entities
 
-  const operation = Operation.DELETE_TABLE
+  const operation = DataSourceOperation.DELETE_TABLE
   await makeTableRequest(datasource, operation, tableToDelete, tables)
 
   cleanupRelationships(tableToDelete, tables)
@@ -336,7 +305,7 @@ export async function destroy(ctx: BBContext) {
   return tableToDelete
 }
 
-export async function bulkImport(ctx: BBContext) {
+exports.bulkImport = async function (ctx) {
   const table = await sdk.tables.getTable(ctx.params.tableId)
   const { dataImport } = ctx.request.body
   if (!dataImport || !dataImport.schema || !dataImport.csvString) {
@@ -346,7 +315,7 @@ export async function bulkImport(ctx: BBContext) {
     ...dataImport,
     existingTable: table,
   })
-  await handleRequest(Operation.BULK_CREATE, table._id!, {
+  await handleRequest(DataSourceOperation.BULK_CREATE, table._id, {
     rows,
   })
   await events.rows.imported(table, "csv", rows.length)

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

@@ -1,13 +1,13 @@
-import * as internal from "./internal"
-import * as external from "./external"
-import * as csvParser from "../../../utilities/csvParser"
-import { isExternalTable, isSQL } from "../../../integrations/utils"
-import { getDatasourceParams } from "../../../db/utils"
-import { context, events } from "@budibase/backend-core"
-import { Table, BBContext } from "@budibase/types"
-import sdk from "../../../sdk"
+const internal = require("./internal")
+const external = require("./external")
+const csvParser = require("../../../utilities/csvParser")
+const { isExternalTable, isSQL } = require("../../../integrations/utils")
+const { getDatasourceParams } = require("../../../db/utils")
+const { getAppDB } = require("@budibase/backend-core/context")
+const { events } = require("@budibase/backend-core")
+const sdk = require("../../../sdk")
 
-function pickApi({ tableId, table }: { tableId?: string; table?: Table }) {
+function pickApi({ tableId, table }) {
   if (table && !tableId) {
     tableId = table._id
   }
@@ -20,8 +20,8 @@ function pickApi({ tableId, table }: { tableId?: string; table?: Table }) {
 }
 
 // covers both internal and external
-export async function fetch(ctx: BBContext) {
-  const db = context.getAppDB()
+exports.fetch = async function (ctx) {
+  const db = getAppDB()
 
   const internal = await sdk.tables.getAllInternalTables()
 
@@ -34,7 +34,7 @@ export async function fetch(ctx: BBContext) {
   const external = externalTables.rows.flatMap(tableDoc => {
     let entities = tableDoc.doc.entities
     if (entities) {
-      return Object.values(entities).map((entity: any) => ({
+      return Object.values(entities).map(entity => ({
         ...entity,
         type: "external",
         sourceId: tableDoc.doc._id,
@@ -48,12 +48,12 @@ export async function fetch(ctx: BBContext) {
   ctx.body = [...internal, ...external]
 }
 
-export async function find(ctx: BBContext) {
+exports.find = async function (ctx) {
   const tableId = ctx.params.tableId
   ctx.body = await sdk.tables.getTable(tableId)
 }
 
-export async function save(ctx: BBContext) {
+exports.save = async function (ctx) {
   const appId = ctx.appId
   const table = ctx.request.body
   const importFormat =
@@ -74,7 +74,7 @@ export async function save(ctx: BBContext) {
   ctx.body = savedTable
 }
 
-export async function destroy(ctx: BBContext) {
+exports.destroy = async function (ctx) {
   const appId = ctx.appId
   const tableId = ctx.params.tableId
   const deletedTable = await pickApi({ tableId }).destroy(ctx)
@@ -86,7 +86,7 @@ export async function destroy(ctx: BBContext) {
   ctx.body = { message: `Table ${tableId} deleted.` }
 }
 
-export async function bulkImport(ctx: BBContext) {
+exports.bulkImport = async function (ctx) {
   const tableId = ctx.params.tableId
   await pickApi({ tableId }).bulkImport(ctx)
   // right now we don't trigger anything for bulk import because it
@@ -96,17 +96,14 @@ export async function bulkImport(ctx: BBContext) {
   ctx.body = { message: `Bulk rows created.` }
 }
 
-export async function validateCSVSchema(ctx: BBContext) {
+exports.validateCSVSchema = async function (ctx) {
   // tableId being specified means its an import to an existing table
   const { csvString, schema = {}, tableId } = ctx.request.body
   let existingTable
   if (tableId) {
     existingTable = await sdk.tables.getTable(tableId)
   }
-  let result: Record<string, any> | undefined = await csvParser.parse(
-    csvString,
-    schema
-  )
+  let result = await csvParser.parse(csvString, schema)
   if (existingTable) {
     result = csvParser.updateSchema({ schema: result, existingTable })
   }

package/src/api/controllers/table/internal.ts

@@ -2,7 +2,7 @@ import { updateLinks, EventType } from "../../../db/linkedRows"
 import { getRowParams, generateTableID } from "../../../db/utils"
 import { FieldTypes } from "../../../constants"
 import { TableSaveFunctions, hasTypeChanged, handleDataImport } from "./utils"
-import { context } from "@budibase/backend-core"
+const { getAppDB } = require("@budibase/backend-core/context")
 import { isTest } from "../../../environment"
 import {
   cleanupAttachments,
@@ -35,7 +35,7 @@ function checkAutoColumns(table: Table, oldTable: Table) {
 }
 
 export async function save(ctx: any) {
-  const db = context.getAppDB()
+  const db = getAppDB()
   const { dataImport, ...rest } = ctx.request.body
   let tableToSave = {
     type: "table",
@@ -133,12 +133,12 @@ export async function save(ctx: any) {
     tableToSave._rev = result.rev
   }
   // has to run after, make sure it has _id
-  await runStaticFormulaChecks(tableToSave, { oldTable, deletion: false })
+  await runStaticFormulaChecks(tableToSave, { oldTable, deletion: null })
   return tableToSave
 }
 
 export async function destroy(ctx: any) {
-  const db = context.getAppDB()
+  const db = getAppDB()
   const tableToDelete = await db.get(ctx.params.tableId)
 
   // Delete all rows for that table
@@ -161,7 +161,7 @@ export async function destroy(ctx: any) {
   })
 
   // don't remove the table itself until very end
-  await db.remove(tableToDelete._id, tableToDelete._rev)
+  await db.remove(tableToDelete)
 
   // remove table search index
   if (!isTest() || env.COUCH_DB_URL) {
@@ -176,6 +176,7 @@ export async function destroy(ctx: any) {
 
   // has to run after, make sure it has _id
   await runStaticFormulaChecks(tableToDelete, {
+    oldTable: null,
     deletion: true,
   })
   await cleanupAttachments(tableToDelete, {