@budibase/server 0.9.188 → 0.9.190-alpha.10

package/dist/api/routes/row.js

@@ -7,15 +7,193 @@ const { paramResource, paramSubResource, } = require("../../middleware/resourceI
 const { PermissionLevels, PermissionTypes, } = require("@budibase/auth/permissions");
 const router = Router();
 router
+    /**
+     * @api {get} /api/:tableId/:rowId/enrich Get an enriched row
+     * @apiName Get an enriched row
+     * @apiGroup rows
+     * @apiPermission table read access
+     * @apiDescription This API is only useful when dealing with rows that have relationships.
+     * Normally when a row is a returned from the API relationships will only have the structure
+     * `{ primaryDisplay: "name", _id: ... }` but this call will return the full related rows
+     * for each relationship instead.
+     *
+     * @apiParam {string} rowId The ID of the row which is to be retrieved and enriched.
+     *
+     * @apiSuccess {object} row The response body will be the enriched row.
+     */
     .get("/api/:tableId/:rowId/enrich", paramSubResource("tableId", "rowId"), authorized(PermissionTypes.TABLE, PermissionLevels.READ), rowController.fetchEnrichedRow)
+    /**
+     * @api {get} /api/:tableId/rows Get all rows in a table
+     * @apiName Get all rows in a table
+     * @apiGroup rows
+     * @apiPermission table read access
+     * @apiDescription This is a deprecated endpoint that should not be used anymore, instead use the search endpoint.
+     * This endpoint gets all of the rows within the specified table - it is not heavily used
+     * due to its lack of support for pagination. With SQL tables this will retrieve up to a limit and then
+     * will simply stop.
+     *
+     * @apiParam {string} tableId The ID of the table to retrieve all rows within.
+     *
+     * @apiSuccess {object[]} rows The response body will be an array of all rows found.
+     */
     .get("/api/:tableId/rows", paramResource("tableId"), authorized(PermissionTypes.TABLE, PermissionLevels.READ), rowController.fetch)
+    /**
+     * @api {get} /api/:tableId/rows/:rowId Retrieve a single row
+     * @apiName Retrieve a single row
+     * @apiGroup rows
+     * @apiPermission table read access
+     * @apiDescription This endpoint retrieves only the specified row. If you wish to retrieve
+     * a row by anything other than its _id field, use the search endpoint.
+     *
+     * @apiParam {string} tableId The ID of the table to retrieve a row from.
+     * @apiParam {string} rowId The ID of the row to retrieve.
+     *
+     * @apiSuccess {object} body The response body will be the row that was found.
+     */
     .get("/api/:tableId/rows/:rowId", paramSubResource("tableId", "rowId"), authorized(PermissionTypes.TABLE, PermissionLevels.READ), rowController.find)
+    /**
+     * @api {post} /api/:tableId/search Search for rows in a table
+     * @apiName Search for rows in a table
+     * @apiGroup rows
+     * @apiPermission table read access
+     * @apiDescription This is the primary method of accessing rows in Budibase, the data provider
+     * and data UI in the builder are built atop this. All filtering, sorting and pagination is
+     * handled through this, for internal and external (datasource plus, e.g. SQL) tables.
+     *
+     * @apiParam {string} tableId The ID of the table to retrieve rows from.
+     *
+     * @apiParam (Body) {boolean} [paginate] If pagination is required then this should be set to true,
+     * defaults to false.
+     * @apiParam (Body) {object} [query] This contains a set of filters which should be applied, if none
+     * specified then the request will be unfiltered. An example with all of the possible query
+     * options has been supplied below.
+     * @apiParam (Body) {number} [limit] This sets a limit for the number of rows that will be returned,
+     * this will be implemented at the database level if supported for performance reasons. This
+     * is useful when paginating to set exactly how many rows per page.
+     * @apiParam (Body) {string} [bookmark] If pagination is enabled then a bookmark will be returned
+     * with each successful search request, this should be supplied back to get the next page.
+     * @apiParam (Body) {object} [sort] If sort is desired this should contain the name of the column to
+     * sort on.
+     * @apiParam (Body) {string} [sortOrder] If sort is enabled then this can be either "descending" or
+     * "ascending" as required.
+     * @apiParam (Body) {string} [sortType] If sort is enabled then you must specify the type of search
+     * being used, either "string" or "number". This is only used for internal tables.
+     *
+     * @apiParamExample {json} Example:
+     * {
+     *  "tableId": "ta_70260ff0b85c467ca74364aefc46f26d",
+     *  "query": {
+     *    "string": {},
+     *    "fuzzy": {},
+     *    "range": {
+     *      "columnName": {
+     *        "high": 20,
+     *        "low": 10,
+     *      }
+     *    },
+     *    "equal": {
+     *      "columnName": "someValue"
+     *    },
+     *    "notEqual": {},
+     *    "empty": {},
+     *    "notEmpty": {},
+     *    "contains": {},
+     *    "notContains": {}
+     *    "oneOf": {
+     *      "columnName": ["value"]
+     *    }
+     *  },
+     *  "limit": 10,
+     *  "sort": "name",
+     *  "sortOrder": "descending",
+     *  "sortType": "string",
+     *  "paginate": true
+     * }
+     *
+     * @apiSuccess {object[]} rows An array of rows that was found based on the supplied parameters.
+     * @apiSuccess {boolean} hasNextPage If pagination was enabled then this specifies whether or
+     * not there is another page after this request.
+     * @apiSuccess {string} bookmark The bookmark to be sent with the next request to get the next
+     * page.
+     */
     .post("/api/:tableId/search", paramResource("tableId"), authorized(PermissionTypes.TABLE, PermissionLevels.READ), rowController.search)
     // DEPRECATED - this is an old API, but for backwards compat it needs to be
     // supported still
     .post("/api/search/:tableId/rows", paramResource("tableId"), authorized(PermissionTypes.TABLE, PermissionLevels.READ), rowController.search)
+    /**
+     * @api {post} /api/:tableId/rows Creates a new row
+     * @apiName Creates a new row
+     * @apiGroup rows
+     * @apiPermission table write access
+     * @apiDescription This API will create a new row based on the supplied body. If the
+     * body includes an "_id" field then it will update an existing row if the field
+     * links to one. Please note that "_id", "_rev" and "tableId" are fields that are
+     * already used by Budibase tables and cannot be used for columns.
+     *
+     * @apiParam {string} tableId The ID of the table to save a row to.
+     *
+     * @apiParam (Body) {string} [_id] If the row exists already then an ID for the row must be provided.
+     * @apiParam (Body) {string} [_rev] If working with an existing row for an internal table its revision
+     * must also be provided.
+     * @apiParam (Body) {string} tableId The ID of the table should also be specified in the row body itself.
+     * @apiParam (Body) {any} [any] Any field supplied in the body will be assessed to see if it matches
+     * a column in the specified table. All other fields will be dropped and not stored.
+     *
+     * @apiSuccess {string} _id The ID of the row that was just saved, if it was just created this
+     * is the rows new ID.
+     * @apiSuccess {string} [_rev] If saving to an internal table a revision will also be returned.
+     * @apiSuccess {object} body The contents of the row that was saved will be returned as well.
+     */
     .post("/api/:tableId/rows", paramResource("tableId"), authorized(PermissionTypes.TABLE, PermissionLevels.WRITE), usage, rowController.save)
+    /**
+     * @api {patch} /api/:tableId/rows Updates a row
+     * @apiName Update a row
+     * @apiGroup rows
+     * @apiPermission table write access
+     * @apiDescription This endpoint is identical to the row creation endpoint but instead it will
+     * error if an _id isn't provided, it will only function for existing rows.
+     */
     .patch("/api/:tableId/rows", paramResource("tableId"), authorized(PermissionTypes.TABLE, PermissionLevels.WRITE), rowController.patch)
+    /**
+     * @api {post} /api/:tableId/rows/validate Validate inputs for a row
+     * @apiName Validate inputs for a row
+     * @apiGroup rows
+     * @apiPermission table write access
+     * @apiDescription When attempting to save a row you may want to check if the row is valid
+     * given the table schema, this will iterate through all the constraints on the table and
+     * check if the request body is valid.
+     *
+     * @apiParam {string} tableId The ID of the table the row is to be validated for.
+     *
+     * @apiParam (Body) {any} [any] Any fields provided in the request body will be tested
+     * against the table schema and constraints.
+     *
+     * @apiSuccess {boolean} valid If inputs provided are acceptable within the table schema this
+     * will be true, if it is not then then errors property will be populated.
+     * @apiSuccess {object} [errors] A key value map of information about fields on the input
+     * which do not match the table schema. The key name will be the column names that have breached
+     * the schema.
+     */
     .post("/api/:tableId/rows/validate", paramResource("tableId"), authorized(PermissionTypes.TABLE, PermissionLevels.WRITE), rowController.validate)
+    /**
+     * @api {delete} /api/:tableId/rows Delete rows
+     * @apiName Delete rows
+     * @apiGroup rows
+     * @apiPermission table write access
+     * @apiDescription This endpoint can delete a single row, or delete them in a bulk
+     * fashion.
+     *
+     * @apiParam {string} tableId The ID of the table the row is to be deleted from.
+     *
+     * @apiParam (Body) {object[]} [rows] If bulk deletion is desired then provide the rows in this
+     * key of the request body that are to be deleted.
+     * @apiParam (Body) {string} [_id] If deleting a single row then provide its ID in this field.
+     * @apiParam (Body) {string} [_rev] If deleting a single row from an internal table then provide its
+     * revision here.
+     *
+     * @apiSuccess {object[]|object} body If deleting bulk then the response body will be an array
+     * of the deleted rows, if deleting a single row then the body will contain a "row" property which
+     * is the deleted row.
+     */
     .delete("/api/:tableId/rows", paramResource("tableId"), authorized(PermissionTypes.TABLE, PermissionLevels.WRITE), usage, rowController.destroy);
 module.exports = router;

package/dist/api/routes/table.js

@@ -21,11 +21,160 @@ function generateSaveValidator() {
     }).unknown(true));
 }
 router
+    /**
+     * @api {get} /api/tables Fetch all tables
+     * @apiName Fetch all tables
+     * @apiGroup tables
+     * @apiPermission table read access
+     * @apiDescription This endpoint retrieves all of the tables which have been created in
+     * an app. This includes all of the external and internal tables; to tell the difference
+     * between these look for the "type" property on each table, either being "internal" or "external".
+     *
+     * @apiSuccess {object[]} body The response body will be the list of tables that was found - as
+     * this does not take any parameters the only error scenario is no access.
+     */
     .get("/api/tables", authorized(BUILDER), tableController.fetch)
+    /**
+     * @api {get} /api/tables/:id Fetch a single table
+     * @apiName Fetch a single table
+     * @apiGroup tables
+     * @apiPermission table read access
+     * @apiDescription Retrieves a single table this could be be internal or external based on
+     * the provided table ID.
+     *
+     * @apiParam {string} id The ID of the table which is to be retrieved.
+     *
+     * @apiSuccess {object[]} body The response body will be the table that was found.
+     */
     .get("/api/tables/:id", paramResource("id"), authorized(PermissionTypes.TABLE, PermissionLevels.READ), tableController.find)
+    /**
+     * @api {post} /api/tables Save a table
+     * @apiName Save a table
+     * @apiGroup tables
+     * @apiPermission builder
+     * @apiDescription Create or update a table with this endpoint, this will function for both internal
+     * external tables.
+     *
+     * @apiParam (Body) {string} [_id] If updating an existing table then the ID of the table must be specified.
+     * @apiParam (Body) {string} [_rev] If updating an existing internal table then the revision must also be specified.
+     * @apiParam (Body) {string} type] This should either be "internal" or "external" depending on the table type -
+     * this will default to internal.
+     * @apiParam (Body) {string} [sourceId] If creating an external table then this should be set to the data source ID. If
+     * building an internal table this does not need to be set, although it will be returned as "bb_internal".
+     * @apiParam (Body) {string} name The name of the table, this will be used in the UI. To rename the table simply
+     * supply the table structure to this endpoint with the name changed.
+     * @apiParam (Body) {object} schema A key value object which has all of the columns in the table as the keys in this
+     * object. For each column a "type" and "constraints" must be specified, with some types requiring further information.
+     * More information about the schema structure can be found in the Typescript definitions.
+     * @apiParam (Body) {string} [primaryDisplay] The name of the column which should be used when displaying rows
+     * from this table as relationships.
+     * @apiParam (Body) {object[]} [indexes] Specifies the search indexes - this is deprecated behaviour with the introduction
+     * of lucene indexes. This functionality is only available for internal tables.
+     * @apiParam (Body) {object} [_rename] If a column is to be renamed then the "old" column name should be set in this
+     * structure, and the "updated", new column name should also be supplied. The schema should also be updated, this field
+     * lets the server know that a field hasn't just been deleted, that the data has moved to a new name, this will fix
+     * the rows in the table. This functionality is only available for internal tables.
+     * @apiParam (Body) {object} [dataImport] When creating an internal table it can be built from a CSV, by using the
+     * CSV validation endpoint. Send the CSV data to the validation endpoint, then put the results of that call
+     * into this property, along with the CSV and a table/rows will be built from it. This is not supported when updating
+     * or for external tables.
+     *
+     * @apiParamExample {json} Example:
+     * {
+     *   "_id": "ta_05541307fa0f4044abee071ca2a82119",
+     *   "_rev": "10-0fbe4e78f69b255d79f1017e2eeef807",
+     *   "type": "internal",
+     *   "views": {},
+     *   "name": "tableName",
+     *   "schema": {
+     *     "column": {
+     *       "type": "string",
+     *       "constraints": {
+     *         "type": "string",
+     *         "length": {
+     *           "maximum": null
+     *         },
+     *         "presence": false
+     *       },
+     *       "name": "column"
+     *     },
+     *   },
+     *   "primaryDisplay": "column",
+     *   "indexes": [],
+     *   "sourceId": "bb_internal",
+     *   "_rename": {
+     *     "old": "columnName",
+     *     "updated": "newColumnName",
+     *   },
+     *   "dataImport": {
+     *     "csvString": "column\nvalue",
+     *     "primaryDisplay": "column",
+     *     "schema": {
+     *       "column": {
+     *         "type": "string"
+     *       }
+     *     }
+     *   }
+     * }
+     *
+     * @apiSuccess {object} table The response body will contain the table structure after being cleaned up and
+     * saved to the database.
+     */
     .post("/api/tables", 
 // allows control over updating a table
 bodyResource("_id"), authorized(BUILDER), generateSaveValidator(), tableController.save)
+    /**
+     * @api {post} /api/tables/csv/validate Validate a CSV for a table
+     * @apiName Validate a CSV for a table
+     * @apiGroup tables
+     * @apiPermission builder
+     * @apiDescription When creating a new table, or importing a CSV to an existing table the CSV must be validated and
+     * converted into a Budibase schema; this endpoint does this.
+     *
+     * @apiParam (Body) {string} csvString The CSV which is to be validated as a string.
+     * @apiParam (Body) {object} [schema] When a CSV has been validated it is possible to re-validate after changing the
+     * type of a field, by default everything will be strings as there is no way to infer types. The returned schema can
+     * be updated and then returned to the endpoint to re-validate and check if the type will work for the CSV, e.g.
+     * using a number instead of strings.
+     * @apiParam (Body) {string} [tableId] If importing data to an existing table this will pull the current table and
+     * remove any fields from the CSV schema which do not exist on the table/don't match the type of the table. When
+     * importing a CSV to an existing table only fields that are present on the table can be imported.
+     *
+     * @apiSuccess {object} schema The response body will contain a "schema" object that represents the schema found for
+     * the CSV - this will be in the same format used for table schema.s
+     */
     .post("/api/tables/csv/validate", authorized(BUILDER), tableController.validateCSVSchema)
-    .delete("/api/tables/:tableId/:revId", paramResource("tableId"), authorized(BUILDER), tableController.destroy);
+    /**
+     * @api {post} /api/tables/:tableId/:revId Delete a table
+     * @apiName Delete a table
+     * @apiGroup tables
+     * @apiPermission builder
+     * @apiDescription This endpoint will delete a table and all of its associated data, for this reason it is
+     * quite dangerous - it will work for internal and external tables.
+     *
+     * @apiParam {string} tableId The ID of the table which is to be deleted.
+     * @apiParam {string} [revId] If deleting an internal table then the revision must also be supplied (_rev), for
+     * external tables this can simply be set to anything, e.g. "external".
+     *
+     * @apiSuccess {string} message A message stating that the table was deleted successfully.
+     */
+    .delete("/api/tables/:tableId/:revId", paramResource("tableId"), authorized(BUILDER), tableController.destroy)
+    /**
+     * @api {post} /api/tables/:tableId/:revId Import CSV to existing table
+     * @apiName Import CSV to existing table
+     * @apiGroup tables
+     * @apiPermission builder
+     * @apiDescription This endpoint will import data to existing tables, internal or external. It is used in combination
+     * with the CSV validation endpoint. Take the output of the CSV validation endpoint and pass it to this endpoint to
+     * import the data; please note this will only import fields that already exist on the table/match the type.
+     *
+     * @apiParam {string} tableId The ID of the table which the data should be imported to.
+     *
+     * @apiParam (Body) {object} dataImport This is the same as the structure used when creating an internal table with
+     * a CSV, it will have the "schema" returned from the CSV validation endpoint and the "csvString" which is to be
+     * turned into rows.
+     *
+     * @apiSuccess {string} message A message stating that the data was imported successfully.
+     */
+    .post("/api/tables/:tableId/import", paramResource("tableId"), authorized(BUILDER), tableController.bulkImport);
 module.exports = router;

package/dist/api/routes/user.js

@@ -9,5 +9,6 @@ router
     .get("/api/users/metadata/:id", authorized(PermissionTypes.USER, PermissionLevels.READ), controller.findMetadata)
     .put("/api/users/metadata", authorized(PermissionTypes.USER, PermissionLevels.WRITE), controller.updateMetadata)
     .post("/api/users/metadata/self", authorized(PermissionTypes.USER, PermissionLevels.WRITE), controller.updateSelfMetadata)
-    .delete("/api/users/metadata/:id", authorized(PermissionTypes.USER, PermissionLevels.WRITE), controller.destroyMetadata);
+    .delete("/api/users/metadata/:id", authorized(PermissionTypes.USER, PermissionLevels.WRITE), controller.destroyMetadata)
+    .post("/api/users/metadata/sync/:id", authorized(PermissionTypes.USER, PermissionLevels.WRITE), controller.syncUser);
 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

@@ -41,6 +41,12 @@ exports.FieldTypes = {
     JSON: "json",
     INTERNAL: "internal",
 };
+exports.SwitchableTypes = [
+    exports.FieldTypes.STRING,
+    exports.FieldTypes.OPTIONS,
+    exports.FieldTypes.NUMBER,
+    exports.FieldTypes.BOOLEAN,
+];
 exports.RelationshipTypes = {
     ONE_TO_MANY: "one-to-many",
     MANY_TO_ONE: "many-to-one",
@@ -56,6 +62,10 @@ exports.DataSourceOperation = {
     READ: "READ",
     UPDATE: "UPDATE",
     DELETE: "DELETE",
+    BULK_CREATE: "BULK_CREATE",
+    CREATE_TABLE: "CREATE_TABLE",
+    UPDATE_TABLE: "UPDATE_TABLE",
+    DELETE_TABLE: "DELETE_TABLE",
 };
 exports.SortDirection = {
     ASCENDING: "ASCENDING",
@@ -140,5 +150,14 @@ exports.MetadataTypes = {
     AUTOMATION_TEST_INPUT: "automationTestInput",
     AUTOMATION_TEST_HISTORY: "automationTestHistory",
 };
+exports.InvalidColumns = {
+    ID: "_id",
+    REV: "_rev",
+    TABLE_ID: "tableId",
+};
+exports.BuildSchemaErrors = {
+    NO_KEY: "no_key",
+    INVALID_COLUMN: "invalid_column",
+};
 // pass through the list from the auth/core lib
 exports.ObjectStoreBuckets = ObjectStoreBuckets;

package/dist/definitions/datasource.js

@@ -1,12 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IncludeRelationships = exports.SourceNames = exports.DatasourceFieldTypes = exports.QueryTypes = exports.SortDirection = exports.Operation = void 0;
+exports.FilterTypes = exports.IncludeRelationships = exports.SourceNames = exports.DatasourceFieldTypes = exports.QueryTypes = exports.SortDirection = exports.Operation = void 0;
 var Operation;
 (function (Operation) {
     Operation["CREATE"] = "CREATE";
     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";
 })(Operation = exports.Operation || (exports.Operation = {}));
 var SortDirection;
 (function (SortDirection) {
@@ -44,9 +48,21 @@ var SourceNames;
     SourceNames["MYSQL"] = "MYSQL";
     SourceNames["ARANGODB"] = "ARANGODB";
     SourceNames["REST"] = "REST";
+    SourceNames["ORACLE"] = "ORACLE";
 })(SourceNames = exports.SourceNames || (exports.SourceNames = {}));
 var IncludeRelationships;
 (function (IncludeRelationships) {
     IncludeRelationships[IncludeRelationships["INCLUDE"] = 1] = "INCLUDE";
     IncludeRelationships[IncludeRelationships["EXCLUDE"] = 0] = "EXCLUDE";
 })(IncludeRelationships = exports.IncludeRelationships || (exports.IncludeRelationships = {}));
+var FilterTypes;
+(function (FilterTypes) {
+    FilterTypes["STRING"] = "string";
+    FilterTypes["FUZZY"] = "fuzzy";
+    FilterTypes["RANGE"] = "range";
+    FilterTypes["EQUAL"] = "equal";
+    FilterTypes["NOT_EQUAL"] = "notEqual";
+    FilterTypes["EMPTY"] = "empty";
+    FilterTypes["NOT_EMPTY"] = "notEmpty";
+    FilterTypes["ONE_OF"] = "oneOf";
+})(FilterTypes = exports.FilterTypes || (exports.FilterTypes = {}));

package/dist/environment.js

@@ -16,6 +16,7 @@ if (!LOADED && isDev() && !isTest()) {
     require("dotenv").config();
     LOADED = true;
 }
+let inThread = false;
 module.exports = {
     // important
     PORT: process.env.PORT,
@@ -55,6 +56,7 @@ module.exports = {
     USERID_API_KEY: process.env.USERID_API_KEY,
     DEPLOYMENT_CREDENTIALS_URL: process.env.DEPLOYMENT_CREDENTIALS_URL,
     ALLOW_DEV_AUTOMATIONS: process.env.ALLOW_DEV_AUTOMATIONS,
+    DISABLE_THREADING: process.env.DISABLE_THREADING,
     _set(key, value) {
         process.env[key] = value;
         module.exports[key] = value;
@@ -65,7 +67,18 @@ module.exports = {
     isProd: () => {
         return !isDev();
     },
+    // used to check if already in a thread, don't thread further
+    setInThread: () => {
+        inThread = true;
+    },
+    isInThread: () => {
+        return inThread;
+    },
 };
+// threading can cause memory issues with node-ts in development
+if (isDev() && module.exports.DISABLE_THREADING == null) {
+    module.exports._set("DISABLE_THREADING", "1");
+}
 // clean up any environment variable edge cases
 for (let [key, value] of Object.entries(module.exports)) {
     // handle the edge case of "0" to disable an environment variable

package/dist/integrations/base/IntegrationBase.js

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

package/dist/integrations/base/datasourcePlus.js

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