@budibase/server 0.9.138 → 0.9.140-alpha.2

package/dist/utilities/appDirectoryTemplate/package.json

@@ -5,6 +5,6 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@budibase/standard-components": "0.x"
+    "@budibase/client": "0.x"
   }
 }

package/dist/utilities/fileSystem/clientLibrary.js

@@ -17,7 +17,7 @@ const env = require("../../environment");
 const TOP_LEVEL_PATH = join(__dirname, "..", "..", "..");
 /**
  * Client library paths in the object store:
- * Previously, the entire standard-components package was downloaded from NPM
+ * Previously, the entire client library package was downloaded from NPM
  * as a tarball and extracted to the object store, even though only the manifest
  * was ever needed. Therefore we need to support old apps which may still have
  * the manifest at this location for the first update.
@@ -79,7 +79,7 @@ exports.updateClientLibrary = (appId) => __awaiter(void 0, void 0, void 0, funct
     let manifest, client;
     if (env.isDev()) {
         // Load the symlinked version in dev which is always the newest
-        manifest = require.resolve("@budibase/standard-components/manifest.json");
+        manifest = require.resolve("@budibase/client/manifest.json");
         client = require.resolve("@budibase/client");
     }
     else {

package/dist/utilities/fileSystem/index.js

@@ -17,13 +17,8 @@ const CouchDB = require("../../db");
 const { ObjectStoreBuckets } = require("../../constants");
 const { upload, retrieve, retrieveToTmp, streamUpload, deleteFolder, downloadTarball, } = require("./utilities");
 const { updateClientLibrary } = require("./clientLibrary");
-const download = require("download");
 const env = require("../../environment");
-const { homedir } = require("os");
-const fetch = require("node-fetch");
 const { USER_METDATA_PREFIX, LINK_USER_METADATA_PREFIX, } = require("../../db/utils");
-const DEFAULT_AUTOMATION_BUCKET = "https://prod-budi-automations.s3-eu-west-1.amazonaws.com";
-const DEFAULT_AUTOMATION_DIRECTORY = ".budibase-automations";
 const TOP_LEVEL_PATH = join(__dirname, "..", "..", "..");
 const NODE_MODULES_PATH = join(TOP_LEVEL_PATH, "node_modules");
 /**
@@ -160,12 +155,13 @@ exports.getComponentLibraryManifest = (appId, library) => __awaiter(void 0, void
     // when testing in cypress and so on we need to get the package
     // as the environment may not be fully fleshed out for dev or prod
     if (env.isTest()) {
+        library = library.replace("standard-components", "client");
         const lib = library.split("/")[1];
         const path = require.resolve(library).split(lib)[0];
         return require(join(path, lib, filename));
     }
     else if (env.isDev()) {
-        const path = join(NODE_MODULES_PATH, "@budibase", "standard-components", filename);
+        const path = join(NODE_MODULES_PATH, "@budibase", "client", filename);
         // always load from new so that updates are refreshed
         delete require.cache[require.resolve(path)];
         return require(path);
@@ -186,27 +182,6 @@ exports.getComponentLibraryManifest = (appId, library) => __awaiter(void 0, void
     }
     return JSON.parse(resp);
 });
-exports.automationInit = () => __awaiter(void 0, void 0, void 0, function* () {
-    const directory = env.AUTOMATION_DIRECTORY || join(homedir(), DEFAULT_AUTOMATION_DIRECTORY);
-    const bucket = env.AUTOMATION_BUCKET || DEFAULT_AUTOMATION_BUCKET;
-    if (!fs.existsSync(directory)) {
-        fs.mkdirSync(directory, { recursive: true });
-    }
-    // env setup to get async packages
-    let response = yield fetch(`${bucket}/manifest.json`);
-    return response.json();
-});
-exports.getExternalAutomationStep = (name, version, bundleName) => __awaiter(void 0, void 0, void 0, function* () {
-    const directory = env.AUTOMATION_DIRECTORY || join(homedir(), DEFAULT_AUTOMATION_DIRECTORY);
-    const bucket = env.AUTOMATION_BUCKET || DEFAULT_AUTOMATION_BUCKET;
-    try {
-        return require(join(directory, bundleName));
-    }
-    catch (err) {
-        yield download(`${bucket}/${name}/${version}/${bundleName}`, directory);
-        return require(join(directory, bundleName));
-    }
-});
 /**
  * All file reads come through here just to make sure all of them make sense
  * allows a centralised location to check logic is all good.

package/dist/utilities/index.js

@@ -1,7 +1,18 @@
 "use strict";
+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 env = require("../environment");
 const { OBJ_STORE_DIRECTORY } = require("../constants");
 const { sanitizeKey } = require("@budibase/auth/src/objectStore");
+const CouchDB = require("../db");
+const { generateMetadataID } = require("../db/utils");
 const BB_CDN = "https://cdn.budi.live";
 exports.wait = ms => new Promise(resolve => setTimeout(resolve, ms));
 exports.isDev = env.isDev;
@@ -47,3 +58,46 @@ exports.clientLibraryPath = appId => {
 exports.attachmentsRelativeURL = attachmentKey => {
     return exports.checkSlashesInUrl(`${exports.objectStoreUrl()}/${attachmentKey}`);
 };
+exports.updateEntityMetadata = (appId, type, entityId, updateFn) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = new CouchDB(appId);
+    const id = generateMetadataID(type, entityId);
+    // read it to see if it exists, we'll overwrite it no matter what
+    let rev, metadata = {};
+    try {
+        const oldMetadata = yield db.get(id);
+        rev = oldMetadata._rev;
+        metadata = updateFn(oldMetadata);
+    }
+    catch (err) {
+        rev = null;
+        metadata = updateFn({});
+    }
+    metadata._id = id;
+    if (rev) {
+        metadata._rev = rev;
+    }
+    const response = yield db.put(metadata);
+    return Object.assign(Object.assign({}, metadata), { _id: id, _rev: response.rev });
+});
+exports.saveEntityMetadata = (appId, type, entityId, metadata) => __awaiter(void 0, void 0, void 0, function* () {
+    return exports.updateEntityMetadata(appId, type, entityId, () => {
+        return metadata;
+    });
+});
+exports.deleteEntityMetadata = (appId, type, entityId) => __awaiter(void 0, void 0, void 0, function* () {
+    const db = new CouchDB(appId);
+    const id = generateMetadataID(type, entityId);
+    let rev;
+    try {
+        const metadata = yield db.get(id);
+        if (metadata) {
+            rev = metadata._rev;
+        }
+    }
+    catch (err) {
+        // don't need to error if it doesn't exist
+    }
+    if (id && rev) {
+        yield db.remove(id, rev);
+    }
+});

package/dist/utilities/redis.js

@@ -11,20 +11,25 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 const { Client, utils } = require("@budibase/auth/redis");
 const { getGlobalIDFromUserMetadataID } = require("../db/utils");
 const APP_DEV_LOCK_SECONDS = 600;
-let devAppClient, debounceClient;
+const AUTOMATION_TEST_FLAG_SECONDS = 60;
+let devAppClient, debounceClient, flagClient;
 // we init this as we want to keep the connection open all the time
 // reduces the performance hit
 exports.init = () => __awaiter(void 0, void 0, void 0, function* () {
     devAppClient = new Client(utils.Databases.DEV_LOCKS);
     debounceClient = new Client(utils.Databases.DEBOUNCE);
+    flagClient = new Client(utils.Databases.FLAGS);
     yield devAppClient.init();
     yield debounceClient.init();
+    yield flagClient.init();
 });
 exports.shutdown = () => __awaiter(void 0, void 0, void 0, function* () {
     if (devAppClient)
         yield devAppClient.finish();
     if (debounceClient)
         yield debounceClient.finish();
+    if (flagClient)
+        yield flagClient.finish();
 });
 exports.doesUserHaveLock = (devAppId, user) => __awaiter(void 0, void 0, void 0, function* () {
     const value = yield devAppClient.get(devAppId);
@@ -66,3 +71,13 @@ exports.checkDebounce = (id) => __awaiter(void 0, void 0, void 0, function* () {
 exports.setDebounce = (id, seconds) => __awaiter(void 0, void 0, void 0, function* () {
     yield debounceClient.store(id, "debouncing", seconds);
 });
+exports.setTestFlag = (id) => __awaiter(void 0, void 0, void 0, function* () {
+    yield flagClient.store(id, { testing: true }, AUTOMATION_TEST_FLAG_SECONDS);
+});
+exports.checkTestFlag = (id) => __awaiter(void 0, void 0, void 0, function* () {
+    const flag = yield flagClient.get(id);
+    return !!(flag && flag.testing);
+});
+exports.clearTestFlag = (id) => __awaiter(void 0, void 0, void 0, function* () {
+    yield devAppClient.delete(id);
+});

package/dist/utilities/rowProcessor/index.js

@@ -190,10 +190,11 @@ exports.inputProcessing = (user = {}, table, row) => {
  * @param {object} ctx the request which is looking for enriched rows.
  * @param {object} table the table from which these rows came from originally, this is used to determine
  * the schema of the rows and then enrich.
- * @param {object[]} rows the rows which are to be enriched.
- * @returns {object[]} the enriched rows will be returned.
+ * @param {object[]|object} rows the rows which are to be enriched.
+ * @param {object} opts used to set some options for the output, such as disabling relationship squashing.
+ * @returns {object[]|object} the enriched rows will be returned.
  */
-exports.outputProcessing = (ctx, table, rows) => __awaiter(void 0, void 0, void 0, function* () {
+exports.outputProcessing = (ctx, table, rows, opts = { squash: true }) => __awaiter(void 0, void 0, void 0, function* () {
     const appId = ctx.appId;
     let wasArray = true;
     if (!(rows instanceof Array)) {
@@ -217,6 +218,8 @@ exports.outputProcessing = (ctx, table, rows) => __awaiter(void 0, void 0, void
             }
         }
     }
-    enriched = yield linkRows.squashLinksToPrimaryDisplay(appId, table, enriched);
+    if (opts.squash) {
+        enriched = yield linkRows.squashLinksToPrimaryDisplay(appId, table, enriched);
+    }
     return wasArray ? enriched : enriched[0];
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@budibase/server",
   "email": "hi@budibase.com",
-  "version": "0.9.138",
+  "version": "0.9.140-alpha.2",
   "description": "Budibase Web Server",
   "main": "src/index.js",
   "repository": {
@@ -13,7 +13,7 @@
     "postbuild": "copyfiles -u 1 src/**/*.svelte dist/ && copyfiles -u 1 src/**/*.hbs dist/ && copyfiles -u 1 src/**/*.json dist/",
     "test": "jest --coverage --maxWorkers=2",
     "test:watch": "jest --watch",
-    "predocker": "copyfiles -f ../client/dist/budibase-client.js ../standard-components/manifest.json client",
+    "predocker": "copyfiles -f ../client/dist/budibase-client.js ../client/manifest.json client",
     "build:docker": "yarn run predocker && docker build . -t app-service",
     "run:docker": "node dist/index.js",
     "dev:stack:up": "node scripts/dev/manage.js up",
@@ -23,9 +23,10 @@
     "format": "prettier --config ../../.prettierrc.json 'src/**/*.ts' --write",
     "lint": "eslint --fix src/",
     "lint:fix": "yarn run format && yarn run lint",
-    "initialise": "node scripts/initialise.js",
     "multi:enable": "node scripts/multiTenancy.js enable",
-    "multi:disable": "node scripts/multiTenancy.js disable"
+    "multi:disable": "node scripts/multiTenancy.js disable",
+    "selfhost:enable": "node scripts/selfhost.js enable",
+    "selfhost:disable": "node scripts/selfhost.js disable"
   },
   "jest": {
     "preset": "ts-jest",
@@ -48,7 +49,8 @@
       "!src/automations/tests/**/*",
       "!src/utilities/fileProcessor.js",
       "!src/utilities/fileSystem/**/*",
-      "!src/utilities/redis.js"
+      "!src/utilities/redis.js",
+      "!src/api/controllers/row/internalSearch.js"
     ],
     "coverageReporters": [
       "lcov",
@@ -62,9 +64,9 @@
   "author": "Budibase",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@budibase/auth": "^0.9.138",
-    "@budibase/client": "^0.9.138",
-    "@budibase/string-templates": "^0.9.138",
+    "@budibase/auth": "^0.9.140-alpha.2",
+    "@budibase/client": "^0.9.140-alpha.2",
+    "@budibase/string-templates": "^0.9.140-alpha.2",
     "@elastic/elasticsearch": "7.10.0",
     "@koa/router": "8.0.0",
     "@sendgrid/mail": "7.1.1",
@@ -96,7 +98,7 @@
     "lodash": "4.17.21",
     "mongodb": "3.6.3",
     "mssql": "6.2.3",
-    "mysql": "2.18.1",
+    "mysql": "^2.18.1",
     "node-fetch": "2.6.0",
     "open": "7.3.0",
     "pg": "8.5.1",
@@ -110,14 +112,13 @@
     "to-json-schema": "0.2.5",
     "uuid": "3.3.2",
     "validate.js": "0.13.1",
-    "worker-farm": "1.7.0",
     "yargs": "13.2.4",
     "zlib": "1.0.5"
   },
   "devDependencies": {
     "@babel/core": "^7.14.3",
     "@babel/preset-env": "^7.14.4",
-    "@budibase/standard-components": "^0.9.138",
+    "@budibase/standard-components": "^0.9.139",
     "@jest/test-sequencer": "^24.8.0",
     "@types/bull": "^3.15.1",
     "@types/jest": "^26.0.23",
@@ -141,5 +142,5 @@
     "typescript": "^4.3.5",
     "update-dotenv": "^1.1.1"
   },
-  "gitHead": "eaba4c2698bbd64f2513d7ff1ce27cf49d9e4394"
+  "gitHead": "53660cfe29eaaa7e89348c367382d04f8f90b2c8"
 }

package/scripts/jestSetup.js

@@ -1,6 +1,7 @@
 const { tmpdir } = require("os")
 const env = require("../src/environment")
 
+env._set("SELF_HOSTED", "1")
 env._set("NODE_ENV", "jest")
 env._set("JWT_SECRET", "test-jwtsecret")
 env._set("CLIENT_ID", "test-client-id")

package/scripts/selfhost.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+const updateDotEnv = require("update-dotenv")
+
+const arg = process.argv.slice(2)[0]
+
+updateDotEnv({
+  SELF_HOSTED: arg === "enable" ? "1" : "0",
+}).then(() => console.log("Updated server!"))

package/src/api/controllers/automation.js

@@ -1,12 +1,14 @@
 const CouchDB = require("../../db")
 const actions = require("../../automations/actions")
-const logic = require("../../automations/logic")
 const triggers = require("../../automations/triggers")
-const webhooks = require("./webhook")
 const { getAutomationParams, generateAutomationID } = require("../../db/utils")
-
-const WH_STEP_ID = triggers.BUILTIN_DEFINITIONS.WEBHOOK.stepId
-const CRON_STEP_ID = triggers.BUILTIN_DEFINITIONS.CRON.stepId
+const {
+  checkForWebhooks,
+  updateTestHistory,
+} = require("../../automations/utils")
+const { deleteEntityMetadata } = require("../../utilities")
+const { MetadataTypes } = require("../../constants")
+const { setTestFlag, clearTestFlag } = require("../../utilities/redis")
 
 /*************************
  *                       *
@@ -14,6 +16,19 @@ const CRON_STEP_ID = triggers.BUILTIN_DEFINITIONS.CRON.stepId
  *                       *
  *************************/
 
+async function cleanupAutomationMetadata(appId, automationId) {
+  await deleteEntityMetadata(
+    appId,
+    MetadataTypes.AUTOMATION_TEST_INPUT,
+    automationId
+  )
+  await deleteEntityMetadata(
+    appId,
+    MetadataTypes.AUTOMATION_TEST_HISTORY,
+    automationId
+  )
+}
+
 function cleanAutomationInputs(automation) {
   if (automation == null) {
     return automation
@@ -21,6 +36,10 @@ function cleanAutomationInputs(automation) {
   let steps = automation.definition.steps
   let trigger = automation.definition.trigger
   let allSteps = [...steps, trigger]
+  // live is not a property used anymore
+  if (automation.live != null) {
+    delete automation.live
+  }
   for (let step of allSteps) {
     if (step == null) {
       continue
@@ -34,119 +53,6 @@ function cleanAutomationInputs(automation) {
   return automation
 }
 
-/**
- * This function handles checking of any cron jobs need to be created or deleted for automations.
- * @param {string} appId The ID of the app in which we are checking for webhooks
- * @param {object|undefined} oldAuto The old automation object if updating/deleting
- * @param {object|undefined} newAuto The new automation object if creating/updating
- */
-async function checkForCronTriggers({ appId, oldAuto, newAuto }) {
-  const oldTrigger = oldAuto ? oldAuto.definition.trigger : null
-  const newTrigger = newAuto ? newAuto.definition.trigger : null
-  function isCronTrigger(auto) {
-    return (
-      auto &&
-      auto.definition.trigger &&
-      auto.definition.trigger.stepId === CRON_STEP_ID
-    )
-  }
-
-  const isLive = auto => auto && auto.live
-
-  const cronTriggerRemoved =
-    isCronTrigger(oldAuto) && !isCronTrigger(newAuto) && oldTrigger.cronJobId
-  const cronTriggerDeactivated = !isLive(newAuto) && isLive(oldAuto)
-
-  const cronTriggerActivated = isLive(newAuto) && !isLive(oldAuto)
-
-  if (cronTriggerRemoved || (cronTriggerDeactivated && oldTrigger.cronJobId)) {
-    await triggers.automationQueue.removeRepeatableByKey(oldTrigger.cronJobId)
-  }
-  // need to create cron job
-  else if (isCronTrigger(newAuto) && cronTriggerActivated) {
-    const job = await triggers.automationQueue.add(
-      {
-        automation: newAuto,
-        event: { appId, timestamp: Date.now() },
-      },
-      { repeat: { cron: newTrigger.inputs.cron } }
-    )
-    // Assign cron job ID from bull so we can remove it later if the cron trigger is removed
-    newTrigger.cronJobId = job.id
-  }
-  return newAuto
-}
-
-/**
- * This function handles checking if any webhooks need to be created or deleted for automations.
- * @param {string} appId The ID of the app in which we are checking for webhooks
- * @param {object|undefined} oldAuto The old automation object if updating/deleting
- * @param {object|undefined} newAuto The new automation object if creating/updating
- * @returns {Promise<object|undefined>} After this is complete the new automation object may have been updated and should be
- * written to DB (this does not write to DB as it would be wasteful to repeat).
- */
-async function checkForWebhooks({ appId, oldAuto, newAuto }) {
-  const oldTrigger = oldAuto ? oldAuto.definition.trigger : null
-  const newTrigger = newAuto ? newAuto.definition.trigger : null
-  const triggerChanged =
-    oldTrigger && newTrigger && oldTrigger.id !== newTrigger.id
-  function isWebhookTrigger(auto) {
-    return (
-      auto &&
-      auto.definition.trigger &&
-      auto.definition.trigger.stepId === WH_STEP_ID
-    )
-  }
-  // need to delete webhook
-  if (
-    isWebhookTrigger(oldAuto) &&
-    (!isWebhookTrigger(newAuto) || triggerChanged) &&
-    oldTrigger.webhookId
-  ) {
-    try {
-      let db = new CouchDB(appId)
-      // need to get the webhook to get the rev
-      const webhook = await db.get(oldTrigger.webhookId)
-      const ctx = {
-        appId,
-        params: { id: webhook._id, rev: webhook._rev },
-      }
-      // might be updating - reset the inputs to remove the URLs
-      if (newTrigger) {
-        delete newTrigger.webhookId
-        newTrigger.inputs = {}
-      }
-      await webhooks.destroy(ctx)
-    } catch (err) {
-      // don't worry about not being able to delete, if it doesn't exist all good
-    }
-  }
-  // need to create webhook
-  if (
-    (!isWebhookTrigger(oldAuto) || triggerChanged) &&
-    isWebhookTrigger(newAuto)
-  ) {
-    const ctx = {
-      appId,
-      request: {
-        body: new webhooks.Webhook(
-          "Automation webhook",
-          webhooks.WebhookType.AUTOMATION,
-          newAuto._id
-        ),
-      },
-    }
-    await webhooks.save(ctx)
-    const id = ctx.body.webhook._id
-    newTrigger.webhookId = id
-    newTrigger.inputs = {
-      schemaUrl: `api/webhooks/schema/${appId}/${id}`,
-      triggerUrl: `api/webhooks/trigger/${appId}/${id}`,
-    }
-  }
-  return newAuto
-}
-
 exports.create = async function (ctx) {
   const db = new CouchDB(ctx.appId)
   let automation = ctx.request.body
@@ -165,10 +71,6 @@ exports.create = async function (ctx) {
     appId: ctx.appId,
     newAuto: automation,
   })
-  automation = await checkForCronTriggers({
-    appId: ctx.appId,
-    newAuto: automation,
-  })
   const response = await db.put(automation)
   automation._rev = response.rev
 
@@ -193,14 +95,26 @@ exports.update = async function (ctx) {
     oldAuto: oldAutomation,
     newAuto: automation,
   })
-  automation = await checkForCronTriggers({
-    appId: ctx.appId,
-    oldAuto: oldAutomation,
-    newAuto: automation,
-  })
   const response = await db.put(automation)
   automation._rev = response.rev
 
+  const oldAutoTrigger =
+    oldAutomation && oldAutomation.definition.trigger
+      ? oldAutomation.definition.trigger
+      : {}
+  const newAutoTrigger =
+    automation && automation.definition.trigger
+      ? automation.definition.trigger
+      : {}
+  // trigger has been updated, remove the test inputs
+  if (oldAutoTrigger.id !== newAutoTrigger.id) {
+    await deleteEntityMetadata(
+      ctx.appId,
+      MetadataTypes.AUTOMATION_TEST_INPUT,
+      automation._id
+    )
+  }
+
   ctx.status = 200
   ctx.body = {
     message: `Automation ${automation._id} updated successfully.`,
@@ -229,35 +143,29 @@ exports.find = async function (ctx) {
 
 exports.destroy = async function (ctx) {
   const db = new CouchDB(ctx.appId)
-  const oldAutomation = await db.get(ctx.params.id)
+  const automationId = ctx.params.id
+  const oldAutomation = await db.get(automationId)
   await checkForWebhooks({
     appId: ctx.appId,
     oldAuto: oldAutomation,
   })
-  await checkForCronTriggers({
-    appId: ctx.appId,
-    oldAuto: oldAutomation,
-  })
-  ctx.body = await db.remove(ctx.params.id, ctx.params.rev)
+  // delete metadata first
+  await cleanupAutomationMetadata(ctx.appId, automationId)
+  ctx.body = await db.remove(automationId, ctx.params.rev)
 }
 
 exports.getActionList = async function (ctx) {
-  ctx.body = actions.DEFINITIONS
+  ctx.body = actions.ACTION_DEFINITIONS
 }
 
 exports.getTriggerList = async function (ctx) {
-  ctx.body = triggers.BUILTIN_DEFINITIONS
-}
-
-exports.getLogicList = async function (ctx) {
-  ctx.body = logic.BUILTIN_DEFINITIONS
+  ctx.body = triggers.TRIGGER_DEFINITIONS
 }
 
 module.exports.getDefinitionList = async function (ctx) {
   ctx.body = {
-    logic: logic.BUILTIN_DEFINITIONS,
-    trigger: triggers.BUILTIN_DEFINITIONS,
-    action: actions.DEFINITIONS,
+    trigger: triggers.TRIGGER_DEFINITIONS,
+    action: actions.ACTION_DEFINITIONS,
   }
 }
 
@@ -268,15 +176,49 @@ module.exports.getDefinitionList = async function (ctx) {
  *********************/
 
 exports.trigger = async function (ctx) {
-  const db = new CouchDB(ctx.appId)
+  const appId = ctx.appId
+  const db = new CouchDB(appId)
   let automation = await db.get(ctx.params.id)
   await triggers.externalTrigger(automation, {
     ...ctx.request.body,
-    appId: ctx.appId,
+    appId,
   })
-  ctx.status = 200
   ctx.body = {
     message: `Automation ${automation._id} has been triggered.`,
     automation,
   }
 }
+
+function prepareTestInput(input) {
+  // prepare the test parameters
+  if (input.id && input.row) {
+    input.row._id = input.id
+  }
+  if (input.revision && input.row) {
+    input.row._rev = input.revision
+  }
+  return input
+}
+
+exports.test = async function (ctx) {
+  const appId = ctx.appId
+  const db = new CouchDB(appId)
+  let automation = await db.get(ctx.params.id)
+  await setTestFlag(automation._id)
+  const testInput = prepareTestInput(ctx.request.body)
+  const response = await triggers.externalTrigger(
+    automation,
+    {
+      ...testInput,
+      appId,
+    },
+    { getResponses: true }
+  )
+  // save a test history run
+  await updateTestHistory(ctx.appId, automation, {
+    ...ctx.request.body,
+    occurredAt: new Date().getTime(),
+  })
+  await clearTestFlag(automation._id)
+  ctx.body = response
+}

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

@@ -1,7 +1,11 @@
 const CouchDB = require("../../../db")
 const Deployment = require("./Deployment")
 const { Replication } = require("@budibase/auth/db")
-const { DocumentTypes } = require("../../../db/utils")
+const { DocumentTypes, getAutomationParams } = require("../../../db/utils")
+const {
+  disableAllCrons,
+  enableCronTrigger,
+} = require("../../../automations/utils")
 
 // the max time we can wait for an invalidation to complete before considering it failed
 const MAX_PENDING_TIME_MS = 30 * 60000
@@ -58,6 +62,23 @@ async function storeDeploymentHistory(deployment) {
   return deployment
 }
 
+async function initDeployedApp(prodAppId) {
+  const db = new CouchDB(prodAppId)
+  const automations = (
+    await db.allDocs(
+      getAutomationParams(null, {
+        include_docs: true,
+      })
+    )
+  ).rows.map(row => row.doc)
+  const promises = []
+  await disableAllCrons(prodAppId)
+  for (let automation of automations) {
+    promises.push(enableCronTrigger(prodAppId, automation))
+  }
+  await Promise.all(promises)
+}
+
 async function deployApp(deployment) {
   try {
     const productionAppId = deployment.appId.replace("_dev", "")
@@ -85,6 +106,7 @@ async function deployApp(deployment) {
       },
     })
 
+    await initDeployedApp(productionAppId)
     deployment.setStatus(DeploymentStatus.SUCCESS)
     await storeDeploymentHistory(deployment)
   } catch (err) {