@budibase/server 2.1.32-alpha.5 → 2.1.32-alpha.7

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

@@ -23,11 +23,9 @@ 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");
 function prepareUpload({ s3Key, bucket, metadata, file }) {
     return __awaiter(this, void 0, void 0, function* () {
         const response = yield upload({
@@ -51,7 +49,7 @@ const toggleBetaUiFeature = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         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`,
             };
@@ -62,8 +60,8 @@ const toggleBetaUiFeature = function (ctx) {
         if (!fs.existsSync(builderPath)) {
             fs.mkdirSync(builderPath);
         }
-        yield downloadTarballDirect("https://cdn.budi.live/beta:design_ui/new_ui.tar.gz", builderPath);
-        setCookie(ctx, {}, cookieName);
+        yield objectStore.downloadTarballDirect("https://cdn.budi.live/beta:design_ui/new_ui.tar.gz", builderPath);
+        utils.setCookie(ctx, {}, cookieName);
         ctx.body = {
             message: `${ctx.params.feature} enabled`,
         };
@@ -104,9 +102,9 @@ const deleteObjects = function (ctx) {
 exports.deleteObjects = deleteObjects;
 const serveApp = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        const db = getAppDB({ skip_setup: true });
+        const db = context.getAppDB({ skip_setup: true });
         const appInfo = yield db.get(DocumentType.APP_METADATA);
-        let appId = getAppId();
+        let appId = context.getAppId();
         if (!env.isJest()) {
             const App = require("./templates/BudibaseApp.svelte").default;
             const plugins = (0, plugins_1.enrichPluginURLs)(appInfo.usedPlugins);
@@ -135,10 +133,10 @@ const serveApp = function (ctx) {
 exports.serveApp = serveApp;
 const serveBuilderPreview = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        const db = getAppDB({ skip_setup: true });
+        const db = context.getAppDB({ skip_setup: true });
         const appInfo = yield db.get(DocumentType.APP_METADATA);
         if (!env.isJest()) {
-            let appId = getAppId();
+            let appId = context.getAppId();
             const previewHbs = loadHandlebarsFile(`${__dirname}/templates/preview.hbs`);
             ctx.body = yield processString(previewHbs, {
                 clientLibPath: clientLibraryPath(appId, appInfo.version, ctx),
@@ -162,7 +160,7 @@ exports.serveClientLibrary = serveClientLibrary;
 const getSignedUploadURL = function (ctx) {
     var _a, _b, _c, _d;
     return __awaiter(this, void 0, void 0, function* () {
-        const database = getAppDB();
+        const database = context.getAppDB();
         // Ensure datasource is valid
         let datasource;
         try {

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

@@ -8,17 +8,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_1 = __importDefault(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 +42,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 +57,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 +72,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 +113,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 +148,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,28 +159,31 @@ 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);
         const oldTables = cloneDeep(datasource.entities);
         const tables = datasource.entities;
         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.";
@@ -178,9 +192,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 = [];
                 }
@@ -196,16 +210,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
@@ -219,37 +229,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, {
+        const rows = yield csvParser_1.default.transform(Object.assign(Object.assign({}, dataImport), { existingTable: table }));
+        yield (0, external_1.handleRequest)(constants_1.DataSourceOperation.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;