@budibase/server 0.9.185-alpha.0 → 0.9.185-alpha.12

package/dist/api/controllers/application.js

@@ -27,6 +27,8 @@ const { getAllLocks } = require("../../utilities/redis");
 const { updateClientLibrary, backupClientLibrary, revertClientLibrary, } = require("../../utilities/fileSystem/clientLibrary");
 const { getTenantId, isMultiTenant } = require("@budibase/auth/tenancy");
 const { syncGlobalUsers } = require("./user");
+const { app: appCache } = require("@budibase/auth/cache");
+const { cleanupAutomations } = require("../../automations/utils");
 const URL_REGEX_SLASH = /\/|\\/g;
 // utility function, need to do away with this
 function getLayouts(db) {
@@ -214,6 +216,7 @@ exports.create = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     if (!env.isTest()) {
         yield createApp(appId);
     }
+    yield appCache.invalidateAppMetadata(appId, newApplication);
     ctx.status = 200;
     ctx.body = newApplication;
 });
@@ -268,8 +271,12 @@ exports.delete = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     if (!env.isTest() && !ctx.query.unpublish) {
         yield deleteApp(ctx.params.appId);
     }
+    if (ctx.query && ctx.query.unpublish) {
+        yield cleanupAutomations(ctx.params.appId);
+    }
     // make sure the app/role doesn't stick around after the app has been deleted
     yield removeAppFromUserRoles(ctx, ctx.params.appId);
+    yield appCache.invalidateAppMetadata(ctx.params.appId);
     ctx.status = 200;
     ctx.body = result;
 });
@@ -331,7 +338,10 @@ const updateAppPackage = (ctx, appPackage, appId) => __awaiter(void 0, void 0, v
     // the locked by property is attached by server but generated from
     // Redis, shouldn't ever store it
     delete newAppPackage.lockedBy;
-    return yield db.put(newAppPackage);
+    const response = yield db.put(newAppPackage);
+    // remove any cached metadata, so that it will be updated
+    yield appCache.invalidateAppMetadata(appId);
+    return response;
 });
 const createEmptyAppPackage = (ctx, app) => __awaiter(void 0, void 0, void 0, function* () {
     const db = new CouchDB(app.appId);

package/dist/api/controllers/datasource.js

@@ -97,8 +97,12 @@ exports.destroy = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const db = new CouchDB(ctx.appId);
         // Delete all queries for the datasource
-        const rows = yield db.allDocs(getQueryParams(ctx.params.datasourceId, null));
-        yield db.bulkDocs(rows.rows.map(row => (Object.assign(Object.assign({}, row.doc), { _deleted: true }))));
+        const queries = yield db.allDocs(getQueryParams(ctx.params.datasourceId, null));
+        yield db.bulkDocs(queries.rows.map(row => ({
+            _id: row.id,
+            _rev: row.value.rev,
+            _deleted: true,
+        })));
         // delete the datasource
         yield db.remove(ctx.params.datasourceId, ctx.params.revId);
         ctx.message = `Datasource deleted.`;

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

@@ -13,6 +13,7 @@ const Deployment = require("./Deployment");
 const { Replication, getDeployedAppID } = require("@budibase/auth/db");
 const { DocumentTypes, getAutomationParams } = require("../../../db/utils");
 const { disableAllCrons, enableCronTrigger, } = require("../../../automations/utils");
+const { app: appCache } = require("@budibase/auth/cache");
 // the max time we can wait for an invalidation to complete before considering it failed
 const MAX_PENDING_TIME_MS = 30 * 60000;
 const DeploymentStatus = {
@@ -95,6 +96,7 @@ function deployApp(deployment) {
             appDoc.appId = productionAppId;
             appDoc.instance._id = productionAppId;
             yield db.put(appDoc);
+            yield appCache.invalidateAppMetadata(productionAppId);
             console.log("New app doc written successfully.");
             yield initDeployedApp(productionAppId);
             console.log("Deployed app initialised, setting deployment to successful");

package/dist/api/controllers/dev.js

@@ -16,6 +16,7 @@ const { request } = require("../../utilities/workerRequests");
 const { clearLock } = require("../../utilities/redis");
 const { Replication } = require("@budibase/auth").db;
 const { DocumentTypes } = require("../../db/utils");
+const { app: appCache } = require("@budibase/auth/cache");
 function redirect(ctx, method, path = "global") {
     return __awaiter(this, void 0, void 0, function* () {
         const { devPath } = ctx.params;
@@ -25,7 +26,8 @@ function redirect(ctx, method, path = "global") {
             body: ctx.request.body,
         }, true));
         if (response.status !== 200) {
-            ctx.throw(response.status, response.statusText);
+            const err = yield response.text();
+            ctx.throw(400, err);
         }
         const cookie = response.headers.get("set-cookie");
         if (cookie) {
@@ -102,6 +104,7 @@ exports.revert = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
         appDoc.appId = appId;
         appDoc.instance._id = appId;
         yield db.put(appDoc);
+        yield appCache.invalidateAppMetadata(appId);
         ctx.body = {
             message: "Reverted changes successfully.",
         };

package/dist/api/controllers/query.js

@@ -11,10 +11,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 const { processString } = require("@budibase/string-templates");
 const CouchDB = require("../../db");
 const { generateQueryID, getQueryParams } = require("../../db/utils");
-const { integrations } = require("../../integrations");
 const { BaseQueryVerbs } = require("../../constants");
 const env = require("../../environment");
-const ScriptRunner = require("../../utilities/scriptRunner");
+const { Thread, ThreadType } = require("../../threads");
+const Runner = new Thread(ThreadType.QUERY, { timeoutMs: 10000 });
 // simple function to append "readable" to all read queries
 function enrichQueries(input) {
     const wasArray = Array.isArray(input);
@@ -26,38 +26,6 @@ function enrichQueries(input) {
     }
     return wasArray ? queries : queries[0];
 }
-function formatResponse(resp) {
-    if (typeof resp === "string") {
-        try {
-            resp = JSON.parse(resp);
-        }
-        catch (err) {
-            resp = { response: resp };
-        }
-    }
-    return resp;
-}
-function runAndTransform(integration, queryVerb, enrichedQuery, transformer) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let rows = formatResponse(yield integration[queryVerb](enrichedQuery));
-        // transform as required
-        if (transformer) {
-            const runner = new ScriptRunner(transformer, { data: rows });
-            rows = runner.execute();
-        }
-        // needs to an array for next step
-        if (!Array.isArray(rows)) {
-            rows = [rows];
-        }
-        // map into JSON if just raw primitive here
-        if (rows.find(row => typeof row !== "object")) {
-            rows = rows.map(value => ({ value }));
-        }
-        // get all the potential fields in the schema
-        let keys = rows.flatMap(Object.keys);
-        return { rows, keys };
-    });
-}
 exports.fetch = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const db = new CouchDB(ctx.appId);
@@ -135,21 +103,22 @@ exports.preview = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const db = new CouchDB(ctx.appId);
         const datasource = yield db.get(ctx.request.body.datasourceId);
-        const Integration = integrations[datasource.source];
-        if (!Integration) {
-            ctx.throw(400, "Integration type does not exist.");
-        }
         const { fields, parameters, queryVerb, transformer } = ctx.request.body;
         const enrichedQuery = yield enrichQueryFields(fields, parameters);
-        const integration = new Integration(datasource.config);
-        const { rows, keys } = yield runAndTransform(integration, queryVerb, enrichedQuery, transformer);
-        ctx.body = {
-            rows,
-            schemaFields: [...new Set(keys)],
-        };
-        // cleanup
-        if (integration.end) {
-            integration.end();
+        try {
+            const { rows, keys } = yield Runner.run({
+                datasource,
+                queryVerb,
+                query: enrichedQuery,
+                transformer,
+            });
+            ctx.body = {
+                rows,
+                schemaFields: [...new Set(keys)],
+            };
+        }
+        catch (err) {
+            ctx.throw(400, err);
         }
     });
 };
@@ -158,18 +127,19 @@ exports.execute = function (ctx) {
         const db = new CouchDB(ctx.appId);
         const query = yield db.get(ctx.params.queryId);
         const datasource = yield db.get(query.datasourceId);
-        const Integration = integrations[datasource.source];
-        if (!Integration) {
-            ctx.throw(400, "Integration type does not exist.");
-        }
         const enrichedQuery = yield enrichQueryFields(query.fields, ctx.request.body.parameters);
-        const integration = new Integration(datasource.config);
         // call the relevant CRUD method on the integration class
-        const { rows } = yield runAndTransform(integration, query.queryVerb, enrichedQuery, query.transformer);
-        ctx.body = rows;
-        // cleanup
-        if (integration.end) {
-            integration.end();
+        try {
+            const { rows } = yield Runner.run({
+                datasource,
+                queryVerb: query.queryVerb,
+                query: enrichedQuery,
+                transformer: query.transformer,
+            });
+            ctx.body = rows;
+        }
+        catch (err) {
+            ctx.throw(400, err);
         }
     });
 };

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

@@ -510,7 +510,7 @@ var External;
                     throw `Unable to process query, table "${tableName}" not defined.`;
                 }
                 // look for specific components of config which may not be considered acceptable
-                let { id, row, filters, sort, paginate } = cleanupConfig(config, table);
+                let { id, row, filters, sort, paginate, rows } = cleanupConfig(config, table);
                 filters = buildFilters(id, filters || {}, table);
                 const relationships = this.buildRelationships(table);
                 // clean up row on ingress using schema
@@ -534,7 +534,7 @@ var External;
                     sort,
                     paginate,
                     relationships,
-                    body: row,
+                    body: row || rows,
                     // pass an id filter into extra, purely for mysql/returning
                     extra: {
                         idFilter: buildFilters(id || generateIdForRow(row, table), {}, table),

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

@@ -41,6 +41,7 @@ function handleRequest(appId, operation, tableId, opts = {}) {
         return new ExternalRequest(appId, operation, tableId, opts.datasource).run(opts);
     });
 }
+exports.handleRequest = handleRequest;
 exports.patch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const appId = ctx.appId;
     const inputs = ctx.request.body;

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

@@ -14,6 +14,8 @@ const { getTable, generateForeignKey, generateJunctionTableName, foreignKeyStruc
 const { DataSourceOperation, FieldTypes, RelationshipTypes, } = require("../../../constants");
 const { makeExternalQuery } = require("../../../integrations/base/utils");
 const { cloneDeep } = require("lodash/fp");
+const csvParser = require("../../../utilities/csvParser");
+const { handleRequest } = require("../row/external");
 function makeTableRequest(datasource, operation, table, tables, oldTable = null) {
     return __awaiter(this, void 0, void 0, function* () {
         const json = {
@@ -223,3 +225,18 @@ exports.destroy = function (ctx) {
         return tableToDelete;
     });
 };
+exports.bulkImport = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const appId = ctx.appId;
+        const table = yield getTable(appId, 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(appId, DataSourceOperation.BULK_CREATE, table._id, {
+            rows,
+        });
+        return table;
+    });
+};

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

@@ -73,10 +73,29 @@ exports.destroy = function (ctx) {
         ctx.body = { message: `Table ${tableId} deleted.` };
     });
 };
+exports.bulkImport = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tableId = ctx.params.tableId;
+        yield pickApi({ tableId }).bulkImport(ctx);
+        // right now we don't trigger anything for bulk import because it
+        // can only be done in the builder, but in the future we may need to
+        // think about events for bulk items
+        ctx.status = 200;
+        ctx.body = { message: `Bulk rows created.` };
+    });
+};
 exports.validateCSVSchema = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { csvString, schema = {} } = ctx.request.body;
-        const result = yield csvParser.parse(csvString, schema);
+        // tableId being specified means its an import to an existing table
+        const { csvString, schema = {}, tableId } = ctx.request.body;
+        let existingTable;
+        if (tableId) {
+            existingTable = yield getTable(ctx.appId, tableId);
+        }
+        let result = yield csvParser.parse(csvString, schema);
+        if (existingTable) {
+            result = csvParser.updateSchema({ schema: result, existingTable });
+        }
         ctx.body = { schema: result };
     });
 };

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

@@ -23,7 +23,7 @@ const CouchDB = require("../../../db");
 const linkRows = require("../../../db/linkedRows");
 const { getRowParams, generateTableID } = require("../../../db/utils");
 const { FieldTypes } = require("../../../constants");
-const { TableSaveFunctions, hasTypeChanged } = require("./utils");
+const { TableSaveFunctions, hasTypeChanged, getTable, handleDataImport, } = require("./utils");
 exports.save = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const appId = ctx.appId;
@@ -139,3 +139,12 @@ exports.destroy = function (ctx) {
         return tableToDelete;
     });
 };
+exports.bulkImport = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const appId = ctx.appId;
+        const table = yield getTable(appId, ctx.params.tableId);
+        const { dataImport } = ctx.request.body;
+        yield handleDataImport(appId, ctx.user, table, dataImport);
+        return table;
+    });
+};

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

@@ -66,37 +66,38 @@ exports.makeSureTableUpToDate = (table, tableToSave) => {
     return tableToSave;
 };
 exports.handleDataImport = (appId, user, table, dataImport) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!dataImport || !dataImport.csvString) {
+        return table;
+    }
     const db = new CouchDB(appId);
-    if (dataImport && dataImport.csvString) {
-        // Populate the table with rows imported from CSV in a bulk update
-        const data = yield csvParser.transform(dataImport);
-        let finalData = [];
-        for (let i = 0; i < data.length; i++) {
-            let row = data[i];
-            row._id = generateRowID(table._id);
-            row.tableId = table._id;
-            const processed = inputProcessing(user, table, row, {
-                noAutoRelationships: true,
-            });
-            table = processed.table;
-            row = processed.row;
-            for (let [fieldName, schema] of Object.entries(table.schema)) {
-                // check whether the options need to be updated for inclusion as part of the data import
-                if (schema.type === FieldTypes.OPTIONS &&
-                    (!schema.constraints.inclusion ||
-                        schema.constraints.inclusion.indexOf(row[fieldName]) === -1)) {
-                    schema.constraints.inclusion = [
-                        ...schema.constraints.inclusion,
-                        row[fieldName],
-                    ];
-                }
+    // Populate the table with rows imported from CSV in a bulk update
+    const data = yield csvParser.transform(Object.assign(Object.assign({}, dataImport), { existingTable: table }));
+    let finalData = [];
+    for (let i = 0; i < data.length; i++) {
+        let row = data[i];
+        row._id = generateRowID(table._id);
+        row.tableId = table._id;
+        const processed = inputProcessing(user, table, row, {
+            noAutoRelationships: true,
+        });
+        table = processed.table;
+        row = processed.row;
+        for (let [fieldName, schema] of Object.entries(table.schema)) {
+            // check whether the options need to be updated for inclusion as part of the data import
+            if (schema.type === FieldTypes.OPTIONS &&
+                (!schema.constraints.inclusion ||
+                    schema.constraints.inclusion.indexOf(row[fieldName]) === -1)) {
+                schema.constraints.inclusion = [
+                    ...schema.constraints.inclusion,
+                    row[fieldName],
+                ];
             }
-            finalData.push(row);
         }
-        yield db.bulkDocs(finalData);
-        let response = yield db.put(table);
-        table._rev = response._rev;
+        finalData.push(row);
     }
+    yield db.bulkDocs(finalData);
+    let response = yield db.put(table);
+    table._rev = response._rev;
     return table;
 });
 exports.handleSearchIndexes = (appId, table) => __awaiter(void 0, void 0, void 0, function* () {

package/dist/api/controllers/user.js

@@ -94,6 +94,7 @@ exports.syncUser = function (ctx) {
                 .map(([appId]) => appId);
         }
         for (let prodAppId of prodAppIds) {
+            const roleId = roles[prodAppId];
             const devAppId = getDevelopmentAppID(prodAppId);
             for (let appId of [prodAppId, devAppId]) {
                 if (!(yield doesDatabaseExist(appId))) {
@@ -113,14 +114,17 @@ exports.syncUser = function (ctx) {
                         tableId: InternalTables.USER_METADATA,
                     };
                 }
-                let combined;
-                if (deleting) {
-                    combined = Object.assign(Object.assign({}, metadata), { status: UserStatus.INACTIVE, metadata: BUILTIN_ROLE_IDS.PUBLIC });
+                // assign the roleId for the metadata doc
+                if (roleId) {
+                    metadata.roleId = roleId;
                 }
-                else {
-                    combined = combineMetadataAndUser(user, metadata);
+                let combined = !deleting
+                    ? combineMetadataAndUser(user, metadata)
+                    : Object.assign(Object.assign({}, metadata), { status: UserStatus.INACTIVE, metadata: BUILTIN_ROLE_IDS.PUBLIC });
+                // if its null then there was no updates required
+                if (combined) {
+                    yield db.put(combined);
                 }
-                yield db.put(combined);
             }
         }
         ctx.body = {

package/dist/api/routes/query.js

@@ -41,7 +41,7 @@ router
     .get("/api/queries", authorized(BUILDER), queryController.fetch)
     .post("/api/queries", bodySubResource("datasourceId", "_id"), authorized(BUILDER), generateQueryValidation(), queryController.save)
     .post("/api/queries/preview", bodyResource("datasourceId"), authorized(BUILDER), generateQueryPreviewValidation(), queryController.preview)
-    .get("/api/queries/:queryId", authorized(PermissionTypes.QUERY, PermissionLevels.READ), queryController.find)
+    .get("/api/queries/:queryId", paramResource("queryId"), authorized(PermissionTypes.QUERY, PermissionLevels.READ), queryController.find)
     .post("/api/queries/:queryId", paramResource("queryId"), authorized(PermissionTypes.QUERY, PermissionLevels.WRITE), queryController.execute)
     .delete("/api/queries/:queryId/:revId", paramResource("queryId"), authorized(BUILDER), queryController.destroy);
 module.exports = router;

package/dist/api/routes/table.js

@@ -27,5 +27,11 @@ router
 // allows control over updating a table
 bodyResource("_id"), authorized(BUILDER), generateSaveValidator(), tableController.save)
     .post("/api/tables/csv/validate", authorized(BUILDER), tableController.validateCSVSchema)
-    .delete("/api/tables/:tableId/:revId", paramResource("tableId"), authorized(BUILDER), tableController.destroy);
+    .delete("/api/tables/:tableId/:revId", paramResource("tableId"), authorized(BUILDER), tableController.destroy)
+    // this is currently builder only, but in the future
+    // it could be carried out by an end user in app,
+    // however some thought will need to be had about
+    // implications for automations (triggers)
+    // new trigger type, bulk rows created
+    .post("/api/tables/:tableId/import", paramResource("tableId"), authorized(BUILDER), tableController.bulkImport);
 module.exports = router;

package/dist/app.js

@@ -41,17 +41,8 @@ app.use(pino({
     level: env.LOG_LEVEL || "error",
 }));
 if (!env.isTest()) {
-    const bullApp = bullboard.init();
-    app.use((ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
-        if (ctx.path.startsWith(bullboard.pathPrefix)) {
-            ctx.status = 200;
-            ctx.respond = false;
-            bullApp(ctx.req, ctx.res);
-        }
-        else {
-            yield next();
-        }
-    }));
+    const plugin = bullboard.init();
+    app.use(plugin);
 }
 app.context.eventEmitter = eventEmitter;
 app.context.auth = {};

package/dist/automations/bullboard.js

@@ -1,7 +1,16 @@
 "use strict";
-const { createBullBoard } = require("bull-board");
-const { BullAdapter } = require("bull-board/bullAdapter");
-const express = require("express");
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const { createBullBoard } = require("@bull-board/api");
+const { BullAdapter } = require("@bull-board/api/bullAdapter");
+const { KoaAdapter } = require("@bull-board/koa");
 const env = require("../environment");
 const Queue = env.isTest()
     ? require("../utilities/queue/inMemoryQueue")
@@ -9,19 +18,37 @@ const Queue = env.isTest()
 const { JobQueues } = require("../constants");
 const { utils } = require("@budibase/auth/redis");
 const { opts, redisProtocolUrl } = utils.getRedisOptions();
-const redisConfig = redisProtocolUrl || { redis: opts };
-let automationQueue = new Queue(JobQueues.AUTOMATIONS, redisConfig);
-exports.pathPrefix = "/bulladmin";
+const CLEANUP_PERIOD_MS = 60 * 1000;
+const queueConfig = redisProtocolUrl || { redis: opts };
+let cleanupInternal = null;
+let automationQueue = new Queue(JobQueues.AUTOMATIONS, queueConfig);
+function cleanup() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield automationQueue.clean(CLEANUP_PERIOD_MS, "completed");
+    });
+}
+const PATH_PREFIX = "/bulladmin";
 exports.init = () => {
-    const expressApp = express();
+    // cleanup the events every 5 minutes
+    if (!cleanupInternal) {
+        cleanupInternal = setInterval(cleanup, CLEANUP_PERIOD_MS);
+        // fire off an initial cleanup
+        cleanup().catch(err => {
+            console.error(`Unable to cleanup automation queue initially - ${err}`);
+        });
+    }
     // Set up queues for bull board admin
     const queues = [automationQueue];
     const adapters = [];
+    const serverAdapter = new KoaAdapter();
     for (let queue of queues) {
         adapters.push(new BullAdapter(queue));
     }
-    const { router } = createBullBoard(adapters);
-    expressApp.use(exports.pathPrefix, router);
-    return expressApp;
+    createBullBoard({
+        queues: adapters,
+        serverAdapter,
+    });
+    serverAdapter.setBasePath(PATH_PREFIX);
+    return serverAdapter.registerPlugin();
 };
 exports.queue = automationQueue;

package/dist/automations/triggers.js

@@ -20,6 +20,10 @@ const { checkTestFlag } = require("../utilities/redis");
 const utils = require("./utils");
 const env = require("../environment");
 const TRIGGER_DEFINITIONS = definitions;
+const JOB_OPTS = {
+    removeOnComplete: true,
+    removeOnFail: true,
+};
 function queueRelevantRowAutomations(event, eventType) {
     return __awaiter(this, void 0, void 0, function* () {
         if (event.appId == null) {
@@ -47,7 +51,7 @@ function queueRelevantRowAutomations(event, eventType) {
             }
             if (automationTrigger.inputs &&
                 automationTrigger.inputs.tableId === event.row.tableId) {
-                yield queue.add({ automation, event });
+                yield queue.add({ automation, event }, JOB_OPTS);
             }
         }
     });
@@ -85,7 +89,7 @@ exports.externalTrigger = function (automation, params, { getResponses } = {}) {
             automation.definition.trigger != null &&
             automation.definition.trigger.stepId === definitions.APP.stepId &&
             automation.definition.trigger.stepId === "APP" &&
-            !checkTestFlag(automation._id)) {
+            !(yield checkTestFlag(automation._id))) {
             // values are likely to be submitted as strings, so we shall convert to correct type
             const coercedFields = {};
             const fields = automation.definition.trigger.inputs.fields;
@@ -99,7 +103,7 @@ exports.externalTrigger = function (automation, params, { getResponses } = {}) {
             return utils.processEvent({ data });
         }
         else {
-            return queue.add(data);
+            return queue.add(data, JOB_OPTS);
         }
     });
 };

package/dist/automations/utils.js

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const runner = require("./thread");
+const { Thread, ThreadType } = require("../threads");
 const { definitions } = require("./triggerInfo");
 const webhooks = require("../api/controllers/webhook");
 const CouchDB = require("../db");
@@ -19,10 +19,11 @@ const { MetadataTypes } = require("../constants");
 const { getDeployedAppID } = require("@budibase/auth/db");
 const WH_STEP_ID = definitions.WEBHOOK.stepId;
 const CRON_STEP_ID = definitions.CRON.stepId;
+const Runner = new Thread(ThreadType.AUTOMATION);
 exports.processEvent = (job) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         // need to actually await these so that an error can be captured properly
-        return yield runner(job);
+        return yield Runner.run(job);
     }
     catch (err) {
         console.error(`${job.data.automation.appId} automation ${job.data.automation._id} was unable to run - ${err}`);
@@ -146,3 +147,11 @@ exports.checkForWebhooks = ({ appId, oldAuto, newAuto }) => __awaiter(void 0, vo
     }
     return newAuto;
 });
+/**
+ * When removing an app/unpublishing it need to make sure automations are cleaned up (cron).
+ * @param appId {string} the app that is being removed.
+ * @return {Promise<void>} clean is complete if this succeeds.
+ */
+exports.cleanupAutomations = (appId) => __awaiter(void 0, void 0, void 0, function* () {
+    yield exports.disableAllCrons(appId);
+});

package/dist/constants/index.js

@@ -62,6 +62,7 @@ exports.DataSourceOperation = {
     READ: "READ",
     UPDATE: "UPDATE",
     DELETE: "DELETE",
+    BULK_CREATE: "BULK_CREATE",
     CREATE_TABLE: "CREATE_TABLE",
     UPDATE_TABLE: "UPDATE_TABLE",
     DELETE_TABLE: "DELETE_TABLE",

package/dist/definitions/datasource.js

@@ -7,6 +7,7 @@ var Operation;
     Operation["READ"] = "READ";
     Operation["UPDATE"] = "UPDATE";
     Operation["DELETE"] = "DELETE";
+    Operation["BULK_CREATE"] = "BULK_CREATE";
     Operation["CREATE_TABLE"] = "CREATE_TABLE";
     Operation["UPDATE_TABLE"] = "UPDATE_TABLE";
     Operation["DELETE_TABLE"] = "DELETE_TABLE";

package/dist/integrations/base/IntegrationBase.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });