@budibase/server 0.0.32 → 0.0.999-alpha.30

package/dist/automations/automationUtils.js

@@ -0,0 +1,173 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typecastForLooping = exports.stringSplit = exports.substituteLoopStep = exports.getError = exports.cleanUpRow = exports.cleanInputValues = void 0;
+const string_templates_1 = require("@budibase/string-templates");
+const sdk_1 = __importDefault(require("../sdk"));
+const automations_1 = require("../definitions/automations");
+/**
+ * When values are input to the system generally they will be of type string as this is required for template strings.
+ * This can generate some odd scenarios as the Schema of the automation requires a number but the builder might supply
+ * a string with template syntax to get the number from the rest of the context. To support this the server has to
+ * make sure that the post template statement can be cast into the correct type, this function does this for numbers
+ * and booleans.
+ *
+ * @param {object} inputs An object of inputs, please note this will not recurse down into any objects within, it simply
+ * cleanses the top level inputs, however it can be used by recursively calling it deeper into the object structures if
+ * the schema is known.
+ * @param {object} schema The defined schema of the inputs, in the form of JSON schema. The schema definition of an
+ * automation is the likely use case of this, however validate.js syntax can be converted closely enough to use this by
+ * wrapping the schema properties in a top level "properties" object.
+ * @returns {object} The inputs object which has had all the various types supported by this function converted to their
+ * primitive types.
+ */
+function cleanInputValues(inputs, schema) {
+    var _a, _b;
+    if (schema == null) {
+        return inputs;
+    }
+    for (let inputKey of Object.keys(inputs)) {
+        let input = inputs[inputKey];
+        if (typeof input !== "string") {
+            continue;
+        }
+        let propSchema = schema.properties[inputKey];
+        if (!propSchema) {
+            continue;
+        }
+        if (propSchema.type === "boolean") {
+            let lcInput = input.toLowerCase();
+            if (lcInput === "true") {
+                inputs[inputKey] = true;
+            }
+            if (lcInput === "false") {
+                inputs[inputKey] = false;
+            }
+        }
+        if (propSchema.type === "number") {
+            let floatInput = parseFloat(input);
+            if (!isNaN(floatInput)) {
+                inputs[inputKey] = floatInput;
+            }
+        }
+    }
+    //Check if input field for Update Row should be a relationship and cast to array
+    for (let key in inputs.row) {
+        if (((_b = (_a = inputs.schema) === null || _a === void 0 ? void 0 : _a[key]) === null || _b === void 0 ? void 0 : _b.type) === "link" &&
+            inputs.row[key] &&
+            typeof inputs.row[key] === "string") {
+            try {
+                inputs.row[key] = JSON.parse(inputs.row[key]);
+            }
+            catch (e) {
+                //Link is not an array or object, so continue
+            }
+        }
+    }
+    return inputs;
+}
+exports.cleanInputValues = cleanInputValues;
+/**
+ * Given a row input like a save or update row we need to clean the inputs against a schema that is not part of
+ * the automation but is instead part of the Table/Table. This function will get the table schema and use it to instead
+ * perform the cleanInputValues function on the input row.
+ *
+ * @param {string} tableId The ID of the Table/Table which the schema is to be retrieved for.
+ * @param {object} row The input row structure which requires clean-up after having been through template statements.
+ * @returns {Promise<Object>} The cleaned up rows object, will should now have all the required primitive types.
+ */
+function cleanUpRow(tableId, row) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let table = yield sdk_1.default.tables.getTable(tableId);
+        return cleanInputValues(row, { properties: table.schema });
+    });
+}
+exports.cleanUpRow = cleanUpRow;
+function getError(err) {
+    if (err == null) {
+        return "No error provided.";
+    }
+    if (typeof err === "object" &&
+        (err.toString == null || err.toString() === "[object Object]")) {
+        return JSON.stringify(err);
+    }
+    return typeof err !== "string" ? err.toString() : err;
+}
+exports.getError = getError;
+function substituteLoopStep(hbsString, substitute) {
+    let checkForJS = (0, string_templates_1.isJSBinding)(hbsString);
+    let substitutedHbsString = "";
+    let open = checkForJS ? `$("` : "{{";
+    let closed = checkForJS ? `")` : "}}";
+    if (checkForJS) {
+        hbsString = (0, string_templates_1.decodeJSBinding)(hbsString);
+    }
+    let pointer = 0, openPointer = 0, closedPointer = 0;
+    while (pointer < (hbsString === null || hbsString === void 0 ? void 0 : hbsString.length)) {
+        openPointer = hbsString.indexOf(open, pointer);
+        closedPointer = hbsString.indexOf(closed, pointer) + 2;
+        if (openPointer < 0 || closedPointer < 0) {
+            substitutedHbsString += hbsString.substring(pointer);
+            break;
+        }
+        let before = hbsString.substring(pointer, openPointer);
+        let block = hbsString
+            .substring(openPointer, closedPointer)
+            .replace(/loop/, substitute);
+        substitutedHbsString += before + block;
+        pointer = closedPointer;
+    }
+    if (checkForJS) {
+        substitutedHbsString = (0, string_templates_1.encodeJSBinding)(substitutedHbsString);
+    }
+    return substitutedHbsString;
+}
+exports.substituteLoopStep = substituteLoopStep;
+function stringSplit(value) {
+    if (value == null || Array.isArray(value)) {
+        return value || [];
+    }
+    if (value.split("\n").length > 1) {
+        value = value.split("\n");
+    }
+    else {
+        value = value.split(",");
+    }
+    return value;
+}
+exports.stringSplit = stringSplit;
+function typecastForLooping(loopStep, input) {
+    if (!input || !input.binding) {
+        return null;
+    }
+    try {
+        switch (loopStep.inputs.option) {
+            case automations_1.LoopStepType.ARRAY:
+                if (typeof input.binding === "string") {
+                    return JSON.parse(input.binding);
+                }
+                break;
+            case automations_1.LoopStepType.STRING:
+                if (Array.isArray(input.binding)) {
+                    return input.binding.join(",");
+                }
+                break;
+        }
+    }
+    catch (err) {
+        throw new Error("Unable to cast to correct type");
+    }
+    return input.binding;
+}
+exports.typecastForLooping = typecastForLooping;

package/dist/automations/bullboard.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shutdown = exports.init = exports.automationQueue = void 0;
+const bullAdapter_1 = require("@bull-board/api/bullAdapter");
+const koa_1 = require("@bull-board/koa");
+const backend_core_1 = require("@budibase/backend-core");
+const automation = __importStar(require("../threads/automation"));
+const pro_1 = require("@budibase/pro");
+const api_1 = require("@bull-board/api");
+exports.automationQueue = backend_core_1.queue.createQueue(backend_core_1.queue.JobQueue.AUTOMATION, { removeStalledCb: automation.removeStalled });
+const PATH_PREFIX = "/bulladmin";
+function init() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Set up queues for bull board admin
+        const backupQueue = yield pro_1.backups.getBackupQueue();
+        const queues = [exports.automationQueue];
+        if (backupQueue) {
+            queues.push(backupQueue);
+        }
+        const adapters = [];
+        const serverAdapter = new koa_1.KoaAdapter();
+        for (let queue of queues) {
+            adapters.push(new bullAdapter_1.BullAdapter(queue));
+        }
+        (0, api_1.createBullBoard)({
+            queues: adapters,
+            serverAdapter,
+        });
+        serverAdapter.setBasePath(PATH_PREFIX);
+        return serverAdapter.registerPlugin();
+    });
+}
+exports.init = init;
+function shutdown() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield backend_core_1.queue.shutdown();
+    });
+}
+exports.shutdown = shutdown;

package/dist/automations/index.js

@@ -0,0 +1,43 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQueues = exports.init = exports.getActionDefinitions = exports.BUILTIN_ACTION_DEFINITIONS = exports.TRIGGER_DEFINITIONS = exports.shutdown = exports.automationQueue = void 0;
+const utils_1 = require("./utils");
+const bullboard_1 = require("./bullboard");
+const triggers_1 = require("./triggers");
+var bullboard_2 = require("./bullboard");
+Object.defineProperty(exports, "automationQueue", { enumerable: true, get: function () { return bullboard_2.automationQueue; } });
+var bullboard_3 = require("./bullboard");
+Object.defineProperty(exports, "shutdown", { enumerable: true, get: function () { return bullboard_3.shutdown; } });
+var triggers_2 = require("./triggers");
+Object.defineProperty(exports, "TRIGGER_DEFINITIONS", { enumerable: true, get: function () { return triggers_2.TRIGGER_DEFINITIONS; } });
+var actions_1 = require("./actions");
+Object.defineProperty(exports, "BUILTIN_ACTION_DEFINITIONS", { enumerable: true, get: function () { return actions_1.BUILTIN_ACTION_DEFINITIONS; } });
+Object.defineProperty(exports, "getActionDefinitions", { enumerable: true, get: function () { return actions_1.getActionDefinitions; } });
+/**
+ * This module is built purely to kick off the worker farm and manage the inputs/outputs
+ */
+function init() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // this promise will not complete
+        const promise = bullboard_1.automationQueue.process((job) => __awaiter(this, void 0, void 0, function* () {
+            yield (0, utils_1.processEvent)(job);
+        }));
+        // on init we need to trigger any reboot automations
+        yield (0, triggers_1.rebootTrigger)();
+        return promise;
+    });
+}
+exports.init = init;
+function getQueues() {
+    return [bullboard_1.automationQueue];
+}
+exports.getQueues = getQueues;

package/dist/automations/logging/index.js

@@ -0,0 +1,53 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAppMetadata = exports.storeLog = void 0;
+const environment_1 = __importDefault(require("../../environment"));
+const pro_1 = require("@budibase/pro");
+const backend_core_1 = require("@budibase/backend-core");
+function storeLog(automation, results) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // can disable this if un-needed in self-host, also only do this for prod apps
+        if (environment_1.default.DISABLE_AUTOMATION_LOGS) {
+            return;
+        }
+        yield pro_1.automations.logs.storeLog(automation, results);
+    });
+}
+exports.storeLog = storeLog;
+function checkAppMetadata(apps) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const maxStartDate = yield pro_1.automations.logs.oldestLogDate();
+        for (let metadata of apps) {
+            if (!metadata.automationErrors) {
+                continue;
+            }
+            for (let [key, errors] of Object.entries(metadata.automationErrors)) {
+                const updated = [];
+                for (let error of errors) {
+                    if (!error) {
+                        continue;
+                    }
+                    const startDate = error.split(backend_core_1.db.SEPARATOR)[2];
+                    if (startDate > maxStartDate) {
+                        updated.push(error);
+                    }
+                }
+                metadata.automationErrors[key] = updated;
+            }
+        }
+        return apps;
+    });
+}
+exports.checkAppMetadata = checkAppMetadata;

package/dist/automations/steps/bash.js

@@ -0,0 +1,111 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = exports.definition = void 0;
+const child_process_1 = require("child_process");
+const string_templates_1 = require("@budibase/string-templates");
+const automationUtils = __importStar(require("../automationUtils"));
+const environment_1 = __importDefault(require("../../environment"));
+const types_1 = require("@budibase/types");
+exports.definition = {
+    name: "Bash Scripting",
+    tagline: "Execute a bash command",
+    icon: "JourneyEvent",
+    description: "Run a bash script",
+    type: types_1.AutomationStepType.ACTION,
+    internal: true,
+    stepId: types_1.AutomationActionStepId.EXECUTE_BASH,
+    inputs: {},
+    schema: {
+        inputs: {
+            properties: {
+                code: {
+                    type: types_1.AutomationIOType.STRING,
+                    customType: types_1.AutomationCustomIOType.CODE,
+                    title: "Code",
+                },
+            },
+            required: ["code"],
+        },
+        outputs: {
+            properties: {
+                stdout: {
+                    type: types_1.AutomationIOType.STRING,
+                    description: "Standard output of your bash command or script",
+                },
+                success: {
+                    type: types_1.AutomationIOType.BOOLEAN,
+                    description: "Whether the command was successful",
+                },
+            },
+            required: ["stdout"],
+        },
+    },
+};
+function run({ inputs, context }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (inputs.code == null) {
+            return {
+                stdout: "Budibase bash automation failed: Invalid inputs",
+            };
+        }
+        try {
+            const command = (0, string_templates_1.processStringSync)(inputs.code, context);
+            let stdout, success = true;
+            try {
+                stdout = (0, child_process_1.execSync)(command, {
+                    timeout: environment_1.default.QUERY_THREAD_TIMEOUT || 500,
+                }).toString();
+            }
+            catch (err) {
+                stdout = err.message;
+                success = false;
+            }
+            return {
+                stdout,
+                success,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                response: automationUtils.getError(err),
+            };
+        }
+    });
+}
+exports.run = run;

package/dist/automations/steps/createRow.js

@@ -0,0 +1,108 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = exports.definition = void 0;
+const row_1 = require("../../api/controllers/row");
+const automationUtils_1 = require("../automationUtils");
+const utils_1 = require("./utils");
+const types_1 = require("@budibase/types");
+exports.definition = {
+    name: "Create Row",
+    tagline: "Create a {{inputs.enriched.table.name}} row",
+    icon: "TableRowAddBottom",
+    description: "Add a row to your database",
+    type: types_1.AutomationStepType.ACTION,
+    internal: true,
+    stepId: types_1.AutomationActionStepId.CREATE_ROW,
+    inputs: {},
+    schema: {
+        inputs: {
+            properties: {
+                row: {
+                    type: types_1.AutomationIOType.OBJECT,
+                    properties: {
+                        tableId: {
+                            type: types_1.AutomationIOType.STRING,
+                            customType: types_1.AutomationCustomIOType.TABLE,
+                        },
+                    },
+                    customType: types_1.AutomationCustomIOType.ROW,
+                    title: "Table",
+                    required: ["tableId"],
+                },
+            },
+            required: ["row"],
+        },
+        outputs: {
+            properties: {
+                row: {
+                    type: types_1.AutomationIOType.OBJECT,
+                    customType: types_1.AutomationCustomIOType.ROW,
+                    description: "The new row",
+                },
+                response: {
+                    type: types_1.AutomationIOType.OBJECT,
+                    description: "The response from the table",
+                },
+                success: {
+                    type: types_1.AutomationIOType.BOOLEAN,
+                    description: "Whether the row creation was successful",
+                },
+                id: {
+                    type: types_1.AutomationIOType.STRING,
+                    description: "The identifier of the new row",
+                },
+                revision: {
+                    type: types_1.AutomationIOType.STRING,
+                    description: "The revision of the new row",
+                },
+            },
+            required: ["success", "id", "revision"],
+        },
+    },
+};
+function run({ inputs, appId, emitter }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (inputs.row == null || inputs.row.tableId == null) {
+            return {
+                success: false,
+                response: {
+                    message: "Invalid inputs",
+                },
+            };
+        }
+        // have to clean up the row, remove the table from it
+        const ctx = (0, utils_1.buildCtx)(appId, emitter, {
+            body: inputs.row,
+            params: {
+                tableId: inputs.row.tableId,
+            },
+        });
+        try {
+            inputs.row = yield (0, automationUtils_1.cleanUpRow)(inputs.row.tableId, inputs.row);
+            yield (0, row_1.save)(ctx);
+            return {
+                row: inputs.row,
+                response: ctx.body,
+                id: ctx.body._id,
+                revision: ctx.body._rev,
+                success: ctx.status === 200,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                response: (0, automationUtils_1.getError)(err),
+            };
+        }
+    });
+}
+exports.run = run;

package/dist/automations/steps/delay.js

@@ -0,0 +1,53 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = exports.definition = void 0;
+const utilities_1 = require("../../utilities");
+const types_1 = require("@budibase/types");
+exports.definition = {
+    name: "Delay",
+    icon: "Clock",
+    tagline: "Delay for {{inputs.time}} milliseconds",
+    description: "Delay the automation until an amount of time has passed",
+    stepId: types_1.AutomationActionStepId.DELAY,
+    internal: true,
+    inputs: {},
+    schema: {
+        inputs: {
+            properties: {
+                time: {
+                    type: types_1.AutomationIOType.NUMBER,
+                    title: "Delay in milliseconds",
+                },
+            },
+            required: ["time"],
+        },
+        outputs: {
+            properties: {
+                success: {
+                    type: types_1.AutomationIOType.BOOLEAN,
+                    description: "Whether the delay was successful",
+                },
+            },
+            required: ["success"],
+        },
+    },
+    type: types_1.AutomationStepType.LOGIC,
+};
+function run({ inputs }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield (0, utilities_1.wait)(inputs.time);
+        return {
+            success: true,
+        };
+    });
+}
+exports.run = run;