@budibase/server 1.0.49-alpha.5 → 1.0.49-alpha.9

package/dist/api/controllers/metadata.js

@@ -9,9 +9,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 const { MetadataTypes } = require("../../constants");
-const CouchDB = require("../../db");
 const { generateMetadataID } = require("../../db/utils");
 const { saveEntityMetadata, deleteEntityMetadata } = require("../../utilities");
+const { getAppDB } = require("@budibase/backend-core/context");
 exports.getTypes = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     ctx.body = {
         types: MetadataTypes,
@@ -22,18 +22,18 @@ exports.saveMetadata = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     if (type === MetadataTypes.AUTOMATION_TEST_HISTORY) {
         ctx.throw(400, "Cannot save automation history type");
     }
-    ctx.body = yield saveEntityMetadata(ctx.appId, type, entityId, ctx.request.body);
+    ctx.body = yield saveEntityMetadata(type, entityId, ctx.request.body);
 });
 exports.deleteMetadata = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const { type, entityId } = ctx.params;
-    yield deleteEntityMetadata(ctx.appId, type, entityId);
+    yield deleteEntityMetadata(type, entityId);
     ctx.body = {
         message: "Metadata deleted successfully",
     };
 });
 exports.getMetadata = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const { type, entityId } = ctx.params;
-    const db = new CouchDB(ctx.appId);
+    const db = getAppDB();
     const id = generateMetadataID(type, entityId);
     try {
         ctx.body = yield db.get(id);

package/dist/api/controllers/permission.js

@@ -11,9 +11,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 const { getBuiltinPermissions } = require("@budibase/backend-core/permissions");
 const { isBuiltin, getDBRoleID, getExternalRoleID, getBuiltinRoles, } = require("@budibase/backend-core/roles");
 const { getRoleParams } = require("../../db/utils");
-const CouchDB = require("../../db");
 const { CURRENTLY_SUPPORTED_LEVELS, getBasePermissions, } = require("../../utilities/security");
 const { removeFromArray } = require("../../utilities");
+const { getAppDB } = require("@budibase/backend-core/context");
 const PermissionUpdateType = {
     REMOVE: "remove",
     ADD: "add",
@@ -30,7 +30,7 @@ function getAllDBRoles(db) {
 }
 function updatePermissionOnRole(appId, { roleId, resourceId, level }, updateType) {
     return __awaiter(this, void 0, void 0, function* () {
-        const db = new CouchDB(appId);
+        const db = getAppDB();
         const remove = updateType === PermissionUpdateType.REMOVE;
         const isABuiltin = isBuiltin(roleId);
         const dbRoleId = getDBRoleID(roleId);
@@ -93,7 +93,7 @@ exports.fetchLevels = function (ctx) {
 };
 exports.fetch = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        const db = new CouchDB(ctx.appId);
+        const db = getAppDB();
         const roles = yield getAllDBRoles(db);
         let permissions = {};
         // create an object with structure role ID -> resource ID -> level
@@ -121,7 +121,7 @@ exports.fetch = function (ctx) {
 exports.getResourcePerms = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const resourceId = ctx.params.resourceId;
-        const db = new CouchDB(ctx.appId);
+        const db = getAppDB();
         const body = yield db.allDocs(getRoleParams(null, {
             include_docs: true,
         }));

package/dist/api/controllers/query/import/index.js

@@ -8,16 +8,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RestImporter = void 0;
-const db_1 = __importDefault(require("../../../../db"));
 const validation_1 = require("../validation");
 const utils_1 = require("../../../../db/utils");
 const openapi2_1 = require("./sources/openapi2");
 const curl_1 = require("./sources/curl");
+// @ts-ignore
+const context_1 = require("@budibase/backend-core/context");
 class RestImporter {
     constructor(data) {
         this.init = () => __awaiter(this, void 0, void 0, function* () {
@@ -31,7 +29,7 @@ class RestImporter {
         this.getInfo = () => __awaiter(this, void 0, void 0, function* () {
             return this.source.getInfo();
         });
-        this.importQueries = (appId, datasourceId) => __awaiter(this, void 0, void 0, function* () {
+        this.importQueries = (datasourceId) => __awaiter(this, void 0, void 0, function* () {
             // constuct the queries
             let queries = yield this.source.getQueries(datasourceId);
             // validate queries
@@ -51,7 +49,7 @@ class RestImporter {
                 return query;
             });
             // persist queries
-            const db = new db_1.default(appId);
+            const db = context_1.getAppDB();
             const response = yield db.bulkDocs(queries);
             // create index to seperate queries and errors
             const queryIndex = queries.reduce((acc, query) => {

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

@@ -8,7 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const CouchDB = require("../../../db");
 const { generateQueryID, getQueryParams, isProdAppID, } = require("../../../db/utils");
 const { BaseQueryVerbs } = require("../../../constants");
 const { Thread, ThreadType } = require("../../../threads");
@@ -16,6 +15,7 @@ const { save: saveDatasource } = require("../datasource");
 const { RestImporter } = require("./import");
 const { invalidateDynamicVariables } = require("../../../threads/utils");
 const environment = require("../../../environment");
+const { getAppDB } = require("@budibase/backend-core/context");
 const Runner = new Thread(ThreadType.QUERY, {
     timeoutMs: environment.QUERY_THREAD_TIMEOUT || 10000,
 });
@@ -32,7 +32,7 @@ function enrichQueries(input) {
 }
 exports.fetch = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        const db = new CouchDB(ctx.appId);
+        const db = getAppDB();
         const body = yield db.allDocs(getQueryParams(null, {
             include_docs: true,
         }));
@@ -67,13 +67,13 @@ exports.import = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
         // use existing datasource
         datasourceId = body.datasourceId;
     }
-    const importResult = yield importer.importQueries(ctx.appId, datasourceId);
+    const importResult = yield importer.importQueries(datasourceId);
     ctx.body = Object.assign(Object.assign({}, importResult), { datasourceId });
     ctx.status = 200;
 });
 exports.save = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        const db = new CouchDB(ctx.appId);
+        const db = getAppDB();
         const query = ctx.request.body;
         if (!query._id) {
             query._id = generateQueryID(query.datasourceId);
@@ -86,7 +86,7 @@ exports.save = function (ctx) {
 };
 exports.find = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        const db = new CouchDB(ctx.appId);
+        const db = getAppDB();
         const query = enrichQueries(yield db.get(ctx.params.queryId));
         // remove properties that could be dangerous in real app
         if (isProdAppID(ctx.appId)) {
@@ -98,7 +98,7 @@ exports.find = function (ctx) {
 };
 exports.preview = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        const db = new CouchDB(ctx.appId);
+        const db = getAppDB();
         const datasource = yield db.get(ctx.request.body.datasourceId);
         // preview may not have a queryId as it hasn't been saved, but if it does
         // this stops dynamic variables from calling the same query
@@ -127,7 +127,7 @@ exports.preview = function (ctx) {
 };
 function execute(ctx, opts = { rowsOnly: false }) {
     return __awaiter(this, void 0, void 0, function* () {
-        const db = new CouchDB(ctx.appId);
+        const db = getAppDB();
         const query = yield db.get(ctx.params.queryId);
         const datasource = yield db.get(query.datasourceId);
         const enrichedParameters = ctx.request.body.parameters || {};
@@ -173,7 +173,8 @@ exports.executeV2 = function (ctx) {
         return execute(ctx, { rowsOnly: false });
     });
 };
-const removeDynamicVariables = (db, queryId) => __awaiter(void 0, void 0, void 0, function* () {
+const removeDynamicVariables = (queryId) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = getAppDB();
     const query = yield db.get(queryId);
     const datasource = yield db.get(query.datasourceId);
     const dynamicVariables = datasource.config.dynamicVariables;
@@ -188,8 +189,8 @@ const removeDynamicVariables = (db, queryId) => __awaiter(void 0, void 0, void 0
 });
 exports.destroy = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        const db = new CouchDB(ctx.appId);
-        yield removeDynamicVariables(db, ctx.params.queryId);
+        const db = getAppDB();
+        yield removeDynamicVariables(ctx.params.queryId);
         yield db.remove(ctx.params.queryId, ctx.params.revId);
         ctx.message = `Query deleted.`;
         ctx.status = 200;

package/dist/api/controllers/role.js

@@ -8,9 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const CouchDB = require("../../db");
 const { Role, getRole, isBuiltin, getAllRoles, } = require("@budibase/backend-core/roles");
 const { generateRoleID, getUserMetadataParams, InternalTables, } = require("../../db/utils");
+const { getAppDB } = require("@budibase/backend-core/context");
 const UpdateRolesOptions = {
     CREATED: "created",
     REMOVED: "removed",
@@ -42,17 +42,17 @@ function updateRolesOnUserTable(db, roleId, updateOption) {
 }
 exports.fetch = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        ctx.body = yield getAllRoles(ctx.appId);
+        ctx.body = yield getAllRoles();
     });
 };
 exports.find = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        ctx.body = yield getRole(ctx.appId, ctx.params.roleId);
+        ctx.body = yield getRole(ctx.params.roleId);
     });
 };
 exports.save = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        const db = new CouchDB(ctx.appId);
+        const db = getAppDB();
         let { _id, name, inherits, permissionId } = ctx.request.body;
         if (!_id) {
             _id = generateRoleID();
@@ -75,7 +75,7 @@ exports.save = function (ctx) {
 };
 exports.destroy = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        const db = new CouchDB(ctx.appId);
+        const db = getAppDB();
         const roleId = ctx.params.roleId;
         if (isBuiltin(roleId)) {
             ctx.throw(400, "Cannot delete builtin role.");

package/dist/api/controllers/routing.js

@@ -40,13 +40,12 @@ Routing.prototype.addScreenId = function (fullpath, roleId, screenId) {
 };
 /**
  * Gets the full routing structure by querying the routing view and processing the result into the tree.
- * @param {string} appId The application to produce the routing structure for.
  * @returns {Promise<object>} The routing structure, this is the full structure designed for use in the builder,
  * if the client routing is required then the updateRoutingStructureForUserRole should be used.
  */
-function getRoutingStructure(appId) {
+function getRoutingStructure() {
     return __awaiter(this, void 0, void 0, function* () {
-        const screenRoutes = yield getRoutingInfo(appId);
+        const screenRoutes = yield getRoutingInfo();
         const routing = new Routing();
         for (let screenRoute of screenRoutes) {
             let fullpath = screenRoute.routing.route;
@@ -57,12 +56,12 @@ function getRoutingStructure(appId) {
     });
 }
 exports.fetch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    ctx.body = yield getRoutingStructure(ctx.appId);
+    ctx.body = yield getRoutingStructure();
 });
 exports.clientFetch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-    const routing = yield getRoutingStructure(ctx.appId);
+    const routing = yield getRoutingStructure();
     let roleId = ctx.user.role._id;
-    const roleIds = yield getUserRoleHierarchy(ctx.appId, roleId);
+    const roleIds = yield getUserRoleHierarchy(roleId);
     for (let topLevel of Object.values(routing.routes)) {
         for (let subpathKey of Object.keys(topLevel.subpaths)) {
             let found = false;

package/dist/api/controllers/row/ExternalRequest.js

@@ -22,19 +22,21 @@ var __rest = (this && this.__rest) || function (s, e) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const datasource_1 = require("../../../definitions/datasource");
 const utils_1 = require("../../../integrations/utils");
+const utils_2 = require("./utils");
+const constants_1 = require("../../../constants");
+const utils_3 = require("../../../integrations/utils");
+const string_templates_1 = require("@budibase/string-templates");
+// @ts-ignore
+const fp_1 = require("lodash/fp");
+const utils_4 = require("../../../utilities/rowProcessor/utils");
+// @ts-ignore
+const context_1 = require("@budibase/backend-core/context");
 var External;
 (function (External) {
-    const { getDatasourceAndQuery } = require("./utils");
-    const { DataSourceOperation, FieldTypes, RelationshipTypes, } = require("../../../constants");
-    const { breakExternalTableId, isSQL } = require("../../../integrations/utils");
-    const { processObjectSync } = require("@budibase/string-templates");
-    const { cloneDeep } = require("lodash/fp");
-    const CouchDB = require("../../../db");
-    const { processFormulas } = require("../../../utilities/rowProcessor/utils");
     function buildFilters(id, filters, table) {
         const primary = table.primary;
         // if passed in array need to copy for shifting etc
-        let idCopy = cloneDeep(id);
+        let idCopy = fp_1.cloneDeep(id);
         if (filters) {
             // need to map over the filters and make sure the _id field isn't present
             for (let filter of Object.values(filters)) {
@@ -77,10 +79,10 @@ var External;
      */
     function cleanupConfig(config, table) {
         const primaryOptions = [
-            FieldTypes.STRING,
-            FieldTypes.LONGFORM,
-            FieldTypes.OPTIONS,
-            FieldTypes.NUMBER,
+            constants_1.FieldTypes.STRING,
+            constants_1.FieldTypes.LONGFORM,
+            constants_1.FieldTypes.OPTIONS,
+            constants_1.FieldTypes.NUMBER,
         ];
         // filter out fields which cannot be keys
         const fieldNames = Object.entries(table.schema)
@@ -133,7 +135,7 @@ var External;
         if (!tableId) {
             return {};
         }
-        const { datasourceId, tableName } = breakExternalTableId(tableId);
+        const { datasourceId, tableName } = utils_3.breakExternalTableId(tableId);
         return {
             datasourceId,
             entityId: tableName,
@@ -153,11 +155,11 @@ var External;
         thisRow._id = generateIdForRow(row, table);
         thisRow.tableId = table._id;
         thisRow._rev = "rev";
-        return thisRow;
+        return utils_4.processFormulas(table, thisRow);
     }
     function fixArrayTypes(row, table) {
         for (let [fieldName, schema] of Object.entries(table.schema)) {
-            if (schema.type === FieldTypes.ARRAY &&
+            if (schema.type === constants_1.FieldTypes.ARRAY &&
                 typeof row[fieldName] === "string") {
                 try {
                     row[fieldName] = JSON.parse(row[fieldName]);
@@ -174,9 +176,8 @@ var External;
         return (field.relationshipType && field.relationshipType.split("-")[0] === "one");
     }
     class ExternalRequest {
-        constructor(appId, operation, tableId, datasource) {
+        constructor(operation, tableId, datasource) {
             this.tables = {};
-            this.appId = appId;
             this.operation = operation;
             this.tableId = tableId;
             this.datasource = datasource;
@@ -188,8 +189,10 @@ var External;
             if (!tableId) {
                 throw "Table ID is unknown, cannot find table";
             }
-            const { tableName } = breakExternalTableId(tableId);
-            return this.tables[tableName];
+            const { tableName } = utils_3.breakExternalTableId(tableId);
+            if (tableName) {
+                return this.tables[tableName];
+            }
         }
         inputProcessing(row, table) {
             if (!row) {
@@ -204,7 +207,7 @@ var External;
                 if (row[key] == null ||
                     newRow[key] ||
                     field.autocolumn ||
-                    field.type === FieldTypes.FORMULA) {
+                    field.type === constants_1.FieldTypes.FORMULA) {
                     continue;
                 }
                 // if its an empty string then it means return the column to null (if possible)
@@ -213,17 +216,17 @@ var External;
                     continue;
                 }
                 // parse floats/numbers
-                if (field.type === FieldTypes.NUMBER && !isNaN(parseFloat(row[key]))) {
+                if (field.type === constants_1.FieldTypes.NUMBER && !isNaN(parseFloat(row[key]))) {
                     newRow[key] = parseFloat(row[key]);
                 }
                 // if its not a link then just copy it over
-                if (field.type !== FieldTypes.LINK) {
+                if (field.type !== constants_1.FieldTypes.LINK) {
                     newRow[key] = row[key];
                     continue;
                 }
-                const { tableName: linkTableName } = breakExternalTableId(field.tableId);
+                const { tableName: linkTableName } = utils_3.breakExternalTableId(field === null || field === void 0 ? void 0 : field.tableId);
                 // table has to exist for many to many
-                if (!this.tables[linkTableName]) {
+                if (!linkTableName || !this.tables[linkTableName]) {
                     continue;
                 }
                 const linkTable = this.tables[linkTableName];
@@ -275,14 +278,24 @@ var External;
          * This iterates through the returned rows and works out what elements of the rows
          * actually match up to another row (based on primary keys) - this is pretty specific
          * to SQL and the way that SQL relationships are returned based on joins.
+         * This is complicated, but the idea is that when a SQL query returns all the relations
+         * will be separate rows, with all of the data in each row. We have to decipher what comes
+         * from where (which tables) and how to convert that into budibase columns.
          */
-        updateRelationshipColumns(row, rows, relationships) {
+        updateRelationshipColumns(table, row, rows, relationships) {
             const columns = {};
             for (let relationship of relationships) {
                 const linkedTable = this.tables[relationship.tableName];
                 if (!linkedTable) {
                     continue;
                 }
+                const fromColumn = `${table.name}.${relationship.from}`;
+                const toColumn = `${linkedTable.name}.${relationship.to}`;
+                // this is important when working with multiple relationships
+                // between the same tables, don't want to overlap/multiply the relations
+                if (!relationship.through && row[fromColumn] !== row[toColumn]) {
+                    continue;
+                }
                 let linked = basicProcessing(row, linkedTable);
                 if (!linked._id) {
                     continue;
@@ -320,7 +333,7 @@ var External;
                 row._id = rowId;
                 // this is a relationship of some sort
                 if (finalRows[rowId]) {
-                    finalRows = this.updateRelationshipColumns(row, finalRows, relationships);
+                    finalRows = this.updateRelationshipColumns(table, row, finalRows, relationships);
                     continue;
                 }
                 const thisRow = fixArrayTypes(basicProcessing(row, table), table);
@@ -329,9 +342,9 @@ var External;
                 }
                 finalRows[thisRow._id] = thisRow;
                 // do this at end once its been added to the final rows
-                finalRows = this.updateRelationshipColumns(row, finalRows, relationships);
+                finalRows = this.updateRelationshipColumns(table, row, finalRows, relationships);
             }
-            return processFormulas(table, Object.values(finalRows));
+            return utils_4.processFormulas(table, Object.values(finalRows));
         }
         /**
          * Gets the list of relationship JSON structures based on the columns in the table,
@@ -341,12 +354,12 @@ var External;
         buildRelationships(table) {
             const relationships = [];
             for (let [fieldName, field] of Object.entries(table.schema)) {
-                if (field.type !== FieldTypes.LINK) {
+                if (field.type !== constants_1.FieldTypes.LINK) {
                     continue;
                 }
-                const { tableName: linkTableName } = breakExternalTableId(field.tableId);
+                const { tableName: linkTableName } = utils_3.breakExternalTableId(field.tableId);
                 // no table to link to, this is not a valid relationships
-                if (!this.tables[linkTableName]) {
+                if (!linkTableName || !this.tables[linkTableName]) {
                     continue;
                 }
                 const linkTable = this.tables[linkTableName];
@@ -362,7 +375,7 @@ var External;
                     column: fieldName,
                 };
                 if (field.through) {
-                    const { tableName: throughTableName } = breakExternalTableId(field.through);
+                    const { tableName: throughTableName } = utils_3.breakExternalTableId(field.through);
                     definition.through = throughTableName;
                     // don't support composite keys for relationships
                     definition.from = field.throughTo || table.primary[0];
@@ -381,21 +394,24 @@ var External;
         lookupRelations(tableId, row) {
             return __awaiter(this, void 0, void 0, function* () {
                 const related = {};
-                const { tableName } = breakExternalTableId(tableId);
+                const { tableName } = utils_3.breakExternalTableId(tableId);
+                if (!tableName) {
+                    return related;
+                }
                 const table = this.tables[tableName];
                 // @ts-ignore
                 const primaryKey = table.primary[0];
                 // make a new request to get the row with all its relationships
                 // we need this to work out if any relationships need removed
                 for (let field of Object.values(table.schema)) {
-                    if (field.type !== FieldTypes.LINK ||
+                    if (field.type !== constants_1.FieldTypes.LINK ||
                         !field.fieldName ||
                         isOneSide(field)) {
                         continue;
                     }
-                    const isMany = field.relationshipType === RelationshipTypes.MANY_TO_MANY;
+                    const isMany = field.relationshipType === constants_1.RelationshipTypes.MANY_TO_MANY;
                     const tableId = isMany ? field.through : field.tableId;
-                    const { tableName: relatedTableName } = breakExternalTableId(tableId);
+                    const { tableName: relatedTableName } = utils_3.breakExternalTableId(tableId);
                     // @ts-ignore
                     const linkPrimaryKey = this.tables[relatedTableName].primary[0];
                     const manyKey = field.throughTo || primaryKey;
@@ -404,8 +420,8 @@ var External;
                     if (!lookupField || !row[lookupField]) {
                         continue;
                     }
-                    const response = yield getDatasourceAndQuery(this.appId, {
-                        endpoint: getEndpoint(tableId, DataSourceOperation.READ),
+                    const response = yield utils_2.getDatasourceAndQuery({
+                        endpoint: getEndpoint(tableId, constants_1.DataSourceOperation.READ),
                         filters: {
                             equal: {
                                 [fieldName]: row[lookupField],
@@ -431,26 +447,27 @@ var External;
          * all and then re-create, as theres no chance of losing data (e.g. delete succeed, but write fail).
          */
         handleManyRelationships(mainTableId, row, relationships) {
-            var _a;
             return __awaiter(this, void 0, void 0, function* () {
-                const { appId } = this;
                 // if we're creating (in a through table) need to wipe the existing ones first
                 const promises = [];
                 const related = yield this.lookupRelations(mainTableId, row);
                 for (let relationship of relationships) {
                     const { key, tableId, isUpdate, id } = relationship, rest = __rest(relationship, ["key", "tableId", "isUpdate", "id"]);
-                    const body = processObjectSync(rest, row);
+                    const body = string_templates_1.processObjectSync(rest, row, {});
                     const linkTable = this.getTable(tableId);
                     // @ts-ignore
-                    const linkPrimary = linkTable.primary[0];
-                    const rows = ((_a = related[key]) === null || _a === void 0 ? void 0 : _a.rows) || [];
+                    const linkPrimary = linkTable === null || linkTable === void 0 ? void 0 : linkTable.primary[0];
+                    if (!linkTable || !linkPrimary) {
+                        return;
+                    }
+                    const rows = related[key].rows || [];
                     const found = rows.find((row) => row[linkPrimary] === relationship.id ||
-                        row[linkPrimary] === body[linkPrimary]);
+                        row[linkPrimary] === (body === null || body === void 0 ? void 0 : body[linkPrimary]));
                     const operation = isUpdate
-                        ? DataSourceOperation.UPDATE
-                        : DataSourceOperation.CREATE;
+                        ? constants_1.DataSourceOperation.UPDATE
+                        : constants_1.DataSourceOperation.CREATE;
                     if (!found) {
-                        promises.push(getDatasourceAndQuery(appId, {
+                        promises.push(utils_2.getDatasourceAndQuery({
                             endpoint: getEndpoint(tableId, operation),
                             // if we're doing many relationships then we're writing, only one response
                             body,
@@ -466,7 +483,8 @@ var External;
                 for (let [colName, { isMany, rows, tableId }] of Object.entries(related)) {
                     const table = this.getTable(tableId);
                     // if its not the foreign key skip it, nothing to do
-                    if (table.primary && table.primary.indexOf(colName) !== -1) {
+                    if (!table ||
+                        (table.primary && table.primary.indexOf(colName) !== -1)) {
                         continue;
                     }
                     for (let row of rows) {
@@ -474,10 +492,10 @@ var External;
                         // safety check, if there are no filters on deletion bad things happen
                         if (Object.keys(filters).length !== 0) {
                             const op = isMany
-                                ? DataSourceOperation.DELETE
-                                : DataSourceOperation.UPDATE;
+                                ? constants_1.DataSourceOperation.DELETE
+                                : constants_1.DataSourceOperation.UPDATE;
                             const body = isMany ? null : { [colName]: null };
-                            promises.push(getDatasourceAndQuery(this.appId, {
+                            promises.push(utils_2.getDatasourceAndQuery({
                                 endpoint: getEndpoint(tableId, op),
                                 body,
                                 filters,
@@ -498,31 +516,36 @@ var External;
         buildFields(table, includeRelations = datasource_1.IncludeRelationships.INCLUDE) {
             function extractRealFields(table, existing = []) {
                 return Object.entries(table.schema)
-                    .filter(column => column[1].type !== FieldTypes.LINK &&
-                    column[1].type !== FieldTypes.FORMULA &&
+                    .filter(column => column[1].type !== constants_1.FieldTypes.LINK &&
+                    column[1].type !== constants_1.FieldTypes.FORMULA &&
                     !existing.find((field) => field === column[0]))
                     .map(column => `${table.name}.${column[0]}`);
             }
             let fields = extractRealFields(table);
             for (let field of Object.values(table.schema)) {
-                if (field.type !== FieldTypes.LINK || !includeRelations) {
+                if (field.type !== constants_1.FieldTypes.LINK || !includeRelations) {
                     continue;
                 }
-                const { tableName: linkTableName } = breakExternalTableId(field.tableId);
-                const linkTable = this.tables[linkTableName];
-                if (linkTable) {
-                    const linkedFields = extractRealFields(linkTable, fields);
-                    fields = fields.concat(linkedFields);
+                const { tableName: linkTableName } = utils_3.breakExternalTableId(field.tableId);
+                if (linkTableName) {
+                    const linkTable = this.tables[linkTableName];
+                    if (linkTable) {
+                        const linkedFields = extractRealFields(linkTable, fields);
+                        fields = fields.concat(linkedFields);
+                    }
                 }
             }
             return fields;
         }
         run(config) {
             return __awaiter(this, void 0, void 0, function* () {
-                const { appId, operation, tableId } = this;
-                let { datasourceId, tableName } = breakExternalTableId(tableId);
+                const { operation, tableId } = this;
+                let { datasourceId, tableName } = utils_3.breakExternalTableId(tableId);
+                if (!tableName) {
+                    throw "Unable to run without a table name";
+                }
                 if (!this.datasource) {
-                    const db = new CouchDB(appId);
+                    const db = context_1.getAppDB();
                     this.datasource = yield db.get(datasourceId);
                     if (!this.datasource || !this.datasource.entities) {
                         throw "No tables found, fetch tables before query.";
@@ -530,7 +553,7 @@ var External;
                     this.tables = this.datasource.entities;
                 }
                 const table = this.tables[tableName];
-                let isSql = isSQL(this.datasource);
+                let isSql = utils_3.isSQL(this.datasource);
                 if (!table) {
                     throw `Unable to process query, table "${tableName}" not defined.`;
                 }
@@ -541,7 +564,7 @@ var External;
                 // clean up row on ingress using schema
                 const processed = this.inputProcessing(row, table);
                 row = processed.row;
-                if (operation === DataSourceOperation.DELETE &&
+                if (operation === constants_1.DataSourceOperation.DELETE &&
                     (filters == null || Object.keys(filters).length === 0)) {
                     throw "Deletion must be filtered";
                 }
@@ -569,15 +592,15 @@ var External;
                     },
                 };
                 // can't really use response right now
-                const response = yield getDatasourceAndQuery(appId, json);
+                const response = yield utils_2.getDatasourceAndQuery(json);
                 // handle many to many relationships now if we know the ID (could be auto increment)
-                if (operation !== DataSourceOperation.READ &&
+                if (operation !== constants_1.DataSourceOperation.READ &&
                     processed.manyRelationships) {
                     yield this.handleManyRelationships(table._id || "", response[0], processed.manyRelationships);
                 }
                 const output = this.outputProcessing(response, table, relationships);
                 // if reading it'll just be an array of rows, return whole thing
-                return operation === DataSourceOperation.READ && Array.isArray(response)
+                return operation === constants_1.DataSourceOperation.READ && Array.isArray(response)
                     ? output
                     : { row: output[0], table };
             });