@budibase/server 2.1.41 → 2.1.43-alpha.0

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

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

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

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

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

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

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

@@ -1,13 +1,13 @@
-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")
+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"
 
-function pickApi({ tableId, table }) {
+function pickApi({ tableId, table }: { tableId?: string; table?: Table }) {
   if (table && !tableId) {
     tableId = table._id
   }
@@ -20,8 +20,8 @@ function pickApi({ tableId, table }) {
 }
 
 // covers both internal and external
-exports.fetch = async function (ctx) {
-  const db = getAppDB()
+export async function fetch(ctx: BBContext) {
+  const db = context.getAppDB()
 
   const internal = await sdk.tables.getAllInternalTables()
 
@@ -34,7 +34,7 @@ exports.fetch = async function (ctx) {
   const external = externalTables.rows.flatMap(tableDoc => {
     let entities = tableDoc.doc.entities
     if (entities) {
-      return Object.values(entities).map(entity => ({
+      return Object.values(entities).map((entity: any) => ({
         ...entity,
         type: "external",
         sourceId: tableDoc.doc._id,
@@ -48,12 +48,12 @@ exports.fetch = async function (ctx) {
   ctx.body = [...internal, ...external]
 }
 
-exports.find = async function (ctx) {
+export async function find(ctx: BBContext) {
   const tableId = ctx.params.tableId
   ctx.body = await sdk.tables.getTable(tableId)
 }
 
-exports.save = async function (ctx) {
+export async function save(ctx: BBContext) {
   const appId = ctx.appId
   const table = ctx.request.body
   const importFormat =
@@ -74,7 +74,7 @@ exports.save = async function (ctx) {
   ctx.body = savedTable
 }
 
-exports.destroy = async function (ctx) {
+export async function destroy(ctx: BBContext) {
   const appId = ctx.appId
   const tableId = ctx.params.tableId
   const deletedTable = await pickApi({ tableId }).destroy(ctx)
@@ -86,7 +86,7 @@ exports.destroy = async function (ctx) {
   ctx.body = { message: `Table ${tableId} deleted.` }
 }
 
-exports.bulkImport = async function (ctx) {
+export async function bulkImport(ctx: BBContext) {
   const tableId = ctx.params.tableId
   await pickApi({ tableId }).bulkImport(ctx)
   // right now we don't trigger anything for bulk import because it
@@ -96,14 +96,17 @@ exports.bulkImport = async function (ctx) {
   ctx.body = { message: `Bulk rows created.` }
 }
 
-exports.validateCSVSchema = async function (ctx) {
+export async function validateCSVSchema(ctx: BBContext) {
   // 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 = await csvParser.parse(csvString, schema)
+  let result: Record<string, any> | undefined = 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"
-const { getAppDB } = require("@budibase/backend-core/context")
+import { context } from "@budibase/backend-core"
 import { isTest } from "../../../environment"
 import {
   cleanupAttachments,
@@ -35,7 +35,7 @@ function checkAutoColumns(table: Table, oldTable: Table) {
 }
 
 export async function save(ctx: any) {
-  const db = getAppDB()
+  const db = context.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: null })
+  await runStaticFormulaChecks(tableToSave, { oldTable, deletion: false })
   return tableToSave
 }
 
 export async function destroy(ctx: any) {
-  const db = getAppDB()
+  const db = context.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)
+  await db.remove(tableToDelete._id, tableToDelete._rev)
 
   // remove table search index
   if (!isTest() || env.COUCH_DB_URL) {
@@ -176,7 +176,6 @@ 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, {