@budibase/server 2.1.42 → 2.1.43-alpha.0

package/dist/api/controllers/table/bulkFormula.js

@@ -8,17 +8,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-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");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStaticFormulaChecks = void 0;
+const constants_1 = require("../../../constants");
+const utils_1 = require("./utils");
+const string_templates_1 = require("@budibase/string-templates");
+const fp_1 = require("lodash/fp");
+const lodash_1 = require("lodash");
+const staticFormula_1 = require("../row/staticFormula");
+const backend_core_1 = require("@budibase/backend-core");
+const sdk_1 = __importDefault(require("../../../sdk"));
 function isStaticFormula(column) {
-    return (column.type === FieldTypes.FORMULA &&
-        column.formulaType === FormulaTypes.STATIC);
+    return (column.type === constants_1.FieldTypes.FORMULA &&
+        column.formulaType === constants_1.FormulaTypes.STATIC);
 }
 /**
  * This retrieves the formula columns from a table schema that use a specified column name
@@ -33,7 +38,7 @@ function getFormulaThatUseColumn(table, columnNames) {
         if (!isStaticFormula(column)) {
             continue;
         }
-        if (!doesContainStrings((_a = column === null || column === void 0 ? void 0 : column.formula) !== null && _a !== void 0 ? _a : "", columnNames)) {
+        if (!(0, string_templates_1.doesContainStrings)((_a = column === null || column === void 0 ? void 0 : column.formula) !== null && _a !== void 0 ? _a : "", columnNames)) {
             continue;
         }
         formula.push(column.name);
@@ -47,19 +52,22 @@ function getFormulaThatUseColumn(table, columnNames) {
 function checkIfFormulaNeedsCleared(table, { oldTable, deletion }) {
     return __awaiter(this, void 0, void 0, function* () {
         // start by retrieving all tables, remove the current table from the list
-        const tables = (yield sdk.tables.getAllInternalTables()).filter(tbl => tbl._id !== table._id);
+        const tables = (yield sdk_1.default.tables.getAllInternalTables()).filter(tbl => tbl._id !== table._id);
         const schemaToUse = oldTable ? oldTable.schema : table.schema;
         let removedColumns = Object.values(schemaToUse).filter(column => deletion || !table.schema[column.name]);
         // remove any formula columns that used related columns
         for (let removed of removedColumns) {
             let tableToUse = table;
             // if relationship, get the related table
-            if (removed.type === FieldTypes.LINK) {
+            if (removed.type === constants_1.FieldTypes.LINK) {
                 tableToUse = tables.find(table => table._id === removed.tableId);
             }
+            if (!tableToUse) {
+                continue;
+            }
             const columnsToDelete = getFormulaThatUseColumn(tableToUse, removed.name);
             if (columnsToDelete.length > 0) {
-                yield clearColumns(table, columnsToDelete);
+                yield (0, utils_1.clearColumns)(table, columnsToDelete);
             }
             // need a special case, where a column has been removed from this table, but was used
             // in a different, related tables formula
@@ -71,7 +79,7 @@ function checkIfFormulaNeedsCleared(table, { oldTable, deletion }) {
                 const relatedTable = tables.find(table => table._id === relatedTableId);
                 // 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) {
+                if (relatedTable && relatedColumns && removed.type !== constants_1.FieldTypes.LINK) {
                     let relatedFormulaToRemove = [];
                     for (let column of relatedColumns) {
                         relatedFormulaToRemove = relatedFormulaToRemove.concat(getFormulaThatUseColumn(relatedTable, [
@@ -80,7 +88,7 @@ function checkIfFormulaNeedsCleared(table, { oldTable, deletion }) {
                         ]));
                     }
                     if (relatedFormulaToRemove.length > 0) {
-                        yield clearColumns(relatedTable, uniq(relatedFormulaToRemove));
+                        yield (0, utils_1.clearColumns)(relatedTable, (0, lodash_1.uniq)(relatedFormulaToRemove));
                     }
                 }
             }
@@ -93,21 +101,22 @@ function checkIfFormulaNeedsCleared(table, { oldTable, deletion }) {
  * can manage hydrating related rows formula fields. This is
  * specifically only for static formula.
  */
-function updateRelatedFormulaLinksOnTables(table, { deletion } = { deletion: false }) {
+function updateRelatedFormulaLinksOnTables(table, { deletion } = {}) {
     return __awaiter(this, void 0, void 0, function* () {
-        const db = getAppDB();
+        const tableId = table._id;
+        const db = backend_core_1.context.getAppDB();
         // start by retrieving all tables, remove the current table from the list
-        const tables = (yield sdk.tables.getAllInternalTables()).filter(tbl => tbl._id !== table._id);
+        const tables = (yield sdk_1.default.tables.getAllInternalTables()).filter(tbl => tbl._id !== tableId);
         // clone the tables, so we can compare at end
-        const initialTables = cloneDeep(tables);
+        const initialTables = (0, fp_1.cloneDeep)(tables);
         // first find the related column names
-        const relatedColumns = Object.values(table.schema).filter(col => col.type === FieldTypes.LINK);
+        const relatedColumns = Object.values(table.schema).filter(col => col.type === constants_1.FieldTypes.LINK);
         // we start by removing the formula field from all tables
         for (let otherTable of tables) {
             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);
             }
@@ -123,17 +132,17 @@ function updateRelatedFormulaLinksOnTables(table, { deletion } = { deletion: fal
                 // check if the table is already in the list of related formula, if it isn't, then add it
                 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];
                 }
             }
         }
         // now we just need to compare all the tables and see if any need saved
         for (let initial of initialTables) {
             const found = tables.find(tbl => initial._id === tbl._id);
-            if (found && !isEqual(initial, found)) {
+            if (found && !(0, lodash_1.isEqual)(initial, found)) {
                 yield db.put(found);
             }
         }
@@ -145,17 +154,20 @@ function checkIfFormulaUpdated(table, { oldTable }) {
         const shouldUpdate = Object.values(table.schema).find(column => isStaticFormula(column) &&
             (!oldTable ||
                 !oldTable.schema[column.name] ||
-                !isEqual(oldTable.schema[column.name], column)));
+                !(0, lodash_1.isEqual)(oldTable.schema[column.name], column)));
         // if a static formula column has updated, then need to run the update
         if (shouldUpdate != null) {
-            yield updateAllFormulasInTable(table);
+            yield (0, staticFormula_1.updateAllFormulasInTable)(table);
         }
     });
 }
-exports.runStaticFormulaChecks = (table, { oldTable, deletion }) => __awaiter(void 0, void 0, void 0, function* () {
-    yield updateRelatedFormulaLinksOnTables(table, { deletion });
-    yield checkIfFormulaNeedsCleared(table, { oldTable, deletion });
-    if (!deletion) {
-        yield checkIfFormulaUpdated(table, { oldTable });
-    }
-});
+function runStaticFormulaChecks(table, { oldTable, deletion }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield updateRelatedFormulaLinksOnTables(table, { deletion });
+        yield checkIfFormulaNeedsCleared(table, { oldTable, deletion });
+        if (!deletion) {
+            yield checkIfFormulaUpdated(table, { oldTable });
+        }
+    });
+}
+exports.runStaticFormulaChecks = runStaticFormulaChecks;

package/dist/api/controllers/table/external.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,17 +31,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const { buildExternalTableId, breakExternalTableId, } = require("../../../integrations/utils");
-const { generateForeignKey, generateJunctionTableName, foreignKeyStructure, hasTypeChanged, } = require("./utils");
-const { DataSourceOperation, FieldTypes, RelationshipTypes, } = require("../../../constants");
-const { makeExternalQuery } = require("../../../integrations/base/query");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bulkImport = exports.destroy = exports.save = void 0;
+const utils_1 = require("../../../integrations/utils");
+const utils_2 = require("./utils");
+const constants_1 = require("../../../constants");
+const query_1 = require("../../../integrations/base/query");
+const csvParser = __importStar(require("../../../utilities/csvParser"));
+const external_1 = require("../row/external");
+const backend_core_1 = require("@budibase/backend-core");
+const types_1 = require("@budibase/types");
+const sdk_1 = __importDefault(require("../../../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");
-function makeTableRequest(datasource, operation, table, tables, oldTable = null, renamed = null) {
+function makeTableRequest(datasource, operation, table, tables, oldTable, renamed) {
     return __awaiter(this, void 0, void 0, function* () {
         const json = {
             endpoint: {
@@ -37,14 +65,14 @@ function makeTableRequest(datasource, operation, table, tables, oldTable = null,
         if (renamed) {
             json.meta.renamed = renamed;
         }
-        return makeExternalQuery(datasource, json);
+        return (0, query_1.makeExternalQuery)(datasource, json);
     });
 }
-function cleanupRelationships(table, tables, oldTable = null) {
+function cleanupRelationships(table, tables, oldTable) {
     const tableToIterate = oldTable ? oldTable : table;
     // clean up relationships in couch table schemas
     for (let [key, schema] of Object.entries(tableToIterate.schema)) {
-        if (schema.type === FieldTypes.LINK &&
+        if (schema.type === constants_1.FieldTypes.LINK &&
             (!oldTable || table.schema[key] == null)) {
             const relatedTable = Object.values(tables).find(table => table._id === schema.tableId);
             const foreignKey = schema.foreignKey;
@@ -52,7 +80,7 @@ function cleanupRelationships(table, tables, oldTable = null) {
                 continue;
             }
             for (let [relatedKey, relatedSchema] of Object.entries(relatedTable.schema)) {
-                if (relatedSchema.type === FieldTypes.LINK &&
+                if (relatedSchema.type === constants_1.FieldTypes.LINK &&
                     relatedSchema.fieldName === foreignKey) {
                     delete relatedTable.schema[relatedKey];
                 }
@@ -67,32 +95,35 @@ function getDatasourceId(table) {
     if (table.sourceId) {
         return table.sourceId;
     }
-    return breakExternalTableId(table._id).datasourceId;
+    return (0, utils_1.breakExternalTableId)(table._id).datasourceId;
 }
 function otherRelationshipType(type) {
-    if (type === RelationshipTypes.MANY_TO_MANY) {
-        return RelationshipTypes.MANY_TO_MANY;
+    if (type === constants_1.RelationshipTypes.MANY_TO_MANY) {
+        return constants_1.RelationshipTypes.MANY_TO_MANY;
     }
-    return type === RelationshipTypes.ONE_TO_MANY
-        ? RelationshipTypes.MANY_TO_ONE
-        : RelationshipTypes.ONE_TO_MANY;
+    return type === constants_1.RelationshipTypes.ONE_TO_MANY
+        ? constants_1.RelationshipTypes.MANY_TO_ONE
+        : constants_1.RelationshipTypes.ONE_TO_MANY;
 }
 function generateManyLinkSchema(datasource, column, table, relatedTable) {
+    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);
+    const jcTblName = (0, utils_2.generateJunctionTableName)(column, table, relatedTable);
     // first create the new table
     const junctionTable = {
-        _id: buildExternalTableId(datasource._id, jcTblName),
+        _id: (0, utils_1.buildExternalTableId)(datasource._id, jcTblName),
         name: jcTblName,
         primary: [primary, relatedPrimary],
         constrained: [primary, relatedPrimary],
         schema: {
-            [primary]: foreignKeyStructure(primary, {
+            [primary]: (0, utils_2.foreignKeyStructure)(primary, {
                 toTable: table.name,
                 toKey: table.primary[0],
             }),
-            [relatedPrimary]: foreignKeyStructure(relatedPrimary, {
+            [relatedPrimary]: (0, utils_2.foreignKeyStructure)(relatedPrimary, {
                 toTable: relatedTable.name,
                 toKey: relatedTable.primary[0],
             }),
@@ -105,10 +136,13 @@ function generateManyLinkSchema(datasource, column, table, relatedTable) {
     return junctionTable;
 }
 function generateLinkSchema(column, table, relatedTable, type) {
-    const isOneSide = type === RelationshipTypes.ONE_TO_MANY;
+    if (!table.primary || !relatedTable.primary) {
+        throw new Error("Unable to generate link schema, no primary keys");
+    }
+    const isOneSide = type === constants_1.RelationshipTypes.ONE_TO_MANY;
     const primary = isOneSide ? relatedTable.primary[0] : table.primary[0];
     // generate a foreign key
-    const foreignKey = generateForeignKey(column, relatedTable);
+    const foreignKey = (0, utils_2.generateForeignKey)(column, relatedTable);
     column.relationshipType = type;
     column.foreignKey = isOneSide ? foreignKey : primary;
     column.fieldName = isOneSide ? primary : foreignKey;
@@ -137,10 +171,10 @@ function generateRelatedSchema(linkColumn, table, relatedTable, columnName) {
 function isRelationshipSetup(column) {
     return column.foreignKey || column.through;
 }
-exports.save = function (ctx) {
+function save(ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const table = ctx.request.body;
-        const { _rename: renamed } = table;
+        const renamed = table === null || table === void 0 ? void 0 : table._rename;
         // can't do this right now
         delete table.dataImport;
         const datasourceId = getDatasourceId(ctx.request.body);
@@ -148,15 +182,15 @@ exports.save = function (ctx) {
         if (!table._id) {
             table.created = true;
         }
-        let tableToSave = Object.assign({ type: "table", _id: buildExternalTableId(datasourceId, table.name) }, table);
+        let tableToSave = Object.assign({ type: "table", _id: (0, utils_1.buildExternalTableId)(datasourceId, table.name) }, table);
         let oldTable;
         if (ctx.request.body && ctx.request.body._id) {
-            oldTable = yield sdk.tables.getTable(ctx.request.body._id);
+            oldTable = yield sdk_1.default.tables.getTable(ctx.request.body._id);
         }
-        if (hasTypeChanged(tableToSave, oldTable)) {
+        if ((0, utils_2.hasTypeChanged)(tableToSave, oldTable)) {
             ctx.throw(400, "A column type has changed.");
         }
-        const db = getAppDB();
+        const db = backend_core_1.context.getAppDB();
         const datasource = yield db.get(datasourceId);
         if (!datasource.entities) {
             datasource.entities = {};
@@ -166,13 +200,16 @@ exports.save = function (ctx) {
         const extraTablesToUpdate = [];
         // check if relations need setup
         for (let schema of Object.values(tableToSave.schema)) {
-            if (schema.type !== FieldTypes.LINK || isRelationshipSetup(schema)) {
+            if (schema.type !== constants_1.FieldTypes.LINK || isRelationshipSetup(schema)) {
                 continue;
             }
             const relatedTable = Object.values(tables).find(table => table._id === schema.tableId);
+            if (!relatedTable) {
+                continue;
+            }
             const relatedColumnName = schema.fieldName;
             const relationType = schema.relationshipType;
-            if (relationType === RelationshipTypes.MANY_TO_MANY) {
+            if (relationType === constants_1.RelationshipTypes.MANY_TO_MANY) {
                 const junctionTable = generateManyLinkSchema(datasource, schema, table, relatedTable);
                 if (tables[junctionTable.name]) {
                     throw "Junction table already exists, cannot create another relationship.";
@@ -181,9 +218,9 @@ exports.save = function (ctx) {
                 extraTablesToUpdate.push(junctionTable);
             }
             else {
-                const fkTable = relationType === RelationshipTypes.ONE_TO_MANY ? table : relatedTable;
+                const fkTable = relationType === constants_1.RelationshipTypes.ONE_TO_MANY ? table : relatedTable;
                 const foreignKey = generateLinkSchema(schema, table, relatedTable, relationType);
-                fkTable.schema[foreignKey] = foreignKeyStructure(foreignKey);
+                fkTable.schema[foreignKey] = (0, utils_2.foreignKeyStructure)(foreignKey);
                 if (fkTable.constrained == null) {
                     fkTable.constrained = [];
                 }
@@ -199,16 +236,12 @@ exports.save = function (ctx) {
             schema.main = true;
         }
         cleanupRelationships(tableToSave, tables, oldTable);
-        const operation = oldTable
-            ? DataSourceOperation.UPDATE_TABLE
-            : DataSourceOperation.CREATE_TABLE;
+        const operation = oldTable ? types_1.Operation.UPDATE_TABLE : types_1.Operation.CREATE_TABLE;
         yield makeTableRequest(datasource, operation, tableToSave, tables, oldTable, renamed);
         // 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 ? types_1.Operation.UPDATE_TABLE : types_1.Operation.CREATE_TABLE;
             yield makeTableRequest(datasource, op, extraTable, tables, oldExtraTable);
         }
         // make sure the constrained list, all still exist
@@ -222,37 +255,40 @@ exports.save = function (ctx) {
         yield db.put(datasource);
         return tableToSave;
     });
-};
-exports.destroy = function (ctx) {
+}
+exports.save = save;
+function destroy(ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        const tableToDelete = yield sdk.tables.getTable(ctx.params.tableId);
+        const tableToDelete = yield sdk_1.default.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 = backend_core_1.context.getAppDB();
         const datasource = yield db.get(datasourceId);
         const tables = datasource.entities;
-        const operation = DataSourceOperation.DELETE_TABLE;
+        const operation = types_1.Operation.DELETE_TABLE;
         yield makeTableRequest(datasource, operation, tableToDelete, tables);
         cleanupRelationships(tableToDelete, tables);
         delete datasource.entities[tableToDelete.name];
         yield db.put(datasource);
         return tableToDelete;
     });
-};
-exports.bulkImport = function (ctx) {
+}
+exports.destroy = destroy;
+function bulkImport(ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        const table = yield sdk.tables.getTable(ctx.params.tableId);
+        const table = yield sdk_1.default.tables.getTable(ctx.params.tableId);
         const { dataImport } = ctx.request.body;
         if (!dataImport || !dataImport.schema || !dataImport.csvString) {
             ctx.throw(400, "Provided data import information is invalid.");
         }
         const rows = yield csvParser.transform(Object.assign(Object.assign({}, dataImport), { existingTable: table }));
-        yield handleRequest(DataSourceOperation.BULK_CREATE, table._id, {
+        yield (0, external_1.handleRequest)(types_1.Operation.BULK_CREATE, table._id, {
             rows,
         });
-        yield events.rows.imported(table, "csv", rows.length);
+        yield backend_core_1.events.rows.imported(table, "csv", rows.length);
         return table;
     });
-};
+}
+exports.bulkImport = bulkImport;

package/dist/api/controllers/table/index.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,14 +31,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-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");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCSVSchema = exports.bulkImport = exports.destroy = exports.save = exports.find = exports.fetch = void 0;
+const internal = __importStar(require("./internal"));
+const external = __importStar(require("./external"));
+const csvParser = __importStar(require("../../../utilities/csvParser"));
+const utils_1 = require("../../../integrations/utils");
+const utils_2 = require("../../../db/utils");
+const backend_core_1 = require("@budibase/backend-core");
+const sdk_1 = __importDefault(require("../../../sdk"));
 function pickApi({ tableId, table }) {
     if (table && !tableId) {
         tableId = table._id;
@@ -23,23 +50,23 @@ function pickApi({ tableId, table }) {
     if (table && table.type === "external") {
         return external;
     }
-    else if (tableId && isExternalTable(tableId)) {
+    else if (tableId && (0, utils_1.isExternalTable)(tableId)) {
         return external;
     }
     return internal;
 }
 // covers both internal and external
-exports.fetch = function (ctx) {
+function fetch(ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        const db = getAppDB();
-        const internal = yield sdk.tables.getAllInternalTables();
-        const externalTables = yield db.allDocs(getDatasourceParams("plus", {
+        const db = backend_core_1.context.getAppDB();
+        const internal = yield sdk_1.default.tables.getAllInternalTables();
+        const externalTables = yield db.allDocs((0, utils_2.getDatasourceParams)("plus", {
             include_docs: true,
         }));
         const external = externalTables.rows.flatMap(tableDoc => {
             let entities = tableDoc.doc.entities;
             if (entities) {
-                return Object.values(entities).map(entity => (Object.assign(Object.assign({}, entity), { type: "external", sourceId: tableDoc.doc._id, sql: isSQL(tableDoc.doc) })));
+                return Object.values(entities).map((entity) => (Object.assign(Object.assign({}, entity), { type: "external", sourceId: tableDoc.doc._id, sql: (0, utils_1.isSQL)(tableDoc.doc) })));
             }
             else {
                 return [];
@@ -47,27 +74,29 @@ exports.fetch = function (ctx) {
         });
         ctx.body = [...internal, ...external];
     });
-};
-exports.find = function (ctx) {
+}
+exports.fetch = fetch;
+function find(ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const tableId = ctx.params.tableId;
-        ctx.body = yield sdk.tables.getTable(tableId);
+        ctx.body = yield sdk_1.default.tables.getTable(tableId);
     });
-};
-exports.save = function (ctx) {
+}
+exports.find = find;
+function save(ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const appId = ctx.appId;
         const table = ctx.request.body;
         const importFormat = table.dataImport && table.dataImport.csvString ? "csv" : undefined;
         const savedTable = yield pickApi({ table }).save(ctx);
         if (!table._id) {
-            yield events.table.created(savedTable);
+            yield backend_core_1.events.table.created(savedTable);
         }
         else {
-            yield events.table.updated(savedTable);
+            yield backend_core_1.events.table.updated(savedTable);
         }
         if (importFormat) {
-            yield events.table.imported(savedTable, importFormat);
+            yield backend_core_1.events.table.imported(savedTable, importFormat);
         }
         ctx.status = 200;
         ctx.message = `Table ${table.name} saved successfully.`;
@@ -75,21 +104,23 @@ exports.save = function (ctx) {
             ctx.eventEmitter.emitTable(`table:save`, appId, savedTable);
         ctx.body = savedTable;
     });
-};
-exports.destroy = function (ctx) {
+}
+exports.save = save;
+function destroy(ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const appId = ctx.appId;
         const tableId = ctx.params.tableId;
         const deletedTable = yield pickApi({ tableId }).destroy(ctx);
-        yield events.table.deleted(deletedTable);
+        yield backend_core_1.events.table.deleted(deletedTable);
         ctx.eventEmitter &&
             ctx.eventEmitter.emitTable(`table:delete`, appId, deletedTable);
         ctx.status = 200;
         ctx.table = deletedTable;
         ctx.body = { message: `Table ${tableId} deleted.` };
     });
-};
-exports.bulkImport = function (ctx) {
+}
+exports.destroy = destroy;
+function bulkImport(ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const tableId = ctx.params.tableId;
         yield pickApi({ tableId }).bulkImport(ctx);
@@ -99,14 +130,15 @@ exports.bulkImport = function (ctx) {
         ctx.status = 200;
         ctx.body = { message: `Bulk rows created.` };
     });
-};
-exports.validateCSVSchema = function (ctx) {
+}
+exports.bulkImport = bulkImport;
+function validateCSVSchema(ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         // tableId being specified means its an import to an existing table
         const { csvString, schema = {}, tableId } = ctx.request.body;
         let existingTable;
         if (tableId) {
-            existingTable = yield sdk.tables.getTable(tableId);
+            existingTable = yield sdk_1.default.tables.getTable(tableId);
         }
         let result = yield csvParser.parse(csvString, schema);
         if (existingTable) {
@@ -114,4 +146,5 @@ exports.validateCSVSchema = function (ctx) {
         }
         ctx.body = { schema: result };
     });
-};
+}
+exports.validateCSVSchema = validateCSVSchema;