@knocklabs/cli 0.1.3 → 0.1.5

package/dist/lib/marshal/email-layout/writer.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    writeEmailLayoutDirFromData: ()=>writeEmailLayoutDirFromData,
+    writeEmailLayoutIndexDir: ()=>writeEmailLayoutIndexDir,
+    buildEmailLayoutDirBundle: ()=>buildEmailLayoutDirBundle,
+    pruneLayoutsIndexDir: ()=>pruneLayoutsIndexDir,
+    toEmailLayoutJson: ()=>toEmailLayoutJson
+});
+const _nodePath = /*#__PURE__*/ _interopRequireDefault(require("node:path"));
+const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
+const _lodash = require("lodash");
+const _const = require("../../helpers/const");
+const _json = require("../../helpers/json");
+const _object = require("../../helpers/object");
+const _helpers = require("../shared/helpers");
+const _helpers1 = require("./helpers");
+const _reader = require("./reader");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+/* Traverse a given email layout data and compile extraction settings of every extractable
+ * field into a sorted map.
+ *
+ * NOTE: Currently we do NOT support content extraction at nested levels for email layouts.
+ */ const compileExtractionSettings = (emailLayout)=>{
+    const extractableFields = (0, _lodash.get)(emailLayout, [
+        "__annotation",
+        "extractable_fields"
+    ], {});
+    const map = new Map();
+    for (const [key] of Object.entries(emailLayout)){
+        // If the field we are on is extractable, then add its extraction
+        // settings to the map with the current object path.
+        if (key in extractableFields) {
+            map.set([
+                key
+            ], extractableFields[key]);
+        }
+    }
+    return map;
+};
+/* Sanitize the email layout content into a format that's appropriate for reading
+ * and writing, by stripping out any annotation fields and handling readonly
+ * fields.
+ */ const toEmailLayoutJson = (emailLayout)=>{
+    var _emailLayout___annotation;
+    // Move read only field under the dedicated field "__readonly".
+    const readonlyFields = ((_emailLayout___annotation = emailLayout.__annotation) === null || _emailLayout___annotation === void 0 ? void 0 : _emailLayout___annotation.readonly_fields) || [];
+    const [readonly, remainder] = (0, _object.split)(emailLayout, readonlyFields);
+    const emailLayoutjson = {
+        ...remainder,
+        __readonly: readonly
+    };
+    // Strip out all schema annotations, so not to expose them to end users.
+    return (0, _object.omitDeep)(emailLayoutjson, [
+        "__annotation"
+    ]);
+};
+const writeEmailLayoutDirFromData = async (emailLayoutDirCtx, remoteEmailLayout)=>{
+    // If the layout directory exists on the file system (i.e. previously
+    // pulled before), then read the layout file to use as a reference.
+    const [localEmailLayout] = emailLayoutDirCtx.exists ? await (0, _reader.readEmailLayoutDir)(emailLayoutDirCtx, {
+        withExtractedFiles: true
+    }) : [];
+    const bundle = buildEmailLayoutDirBundle(remoteEmailLayout, localEmailLayout);
+    const backupDirPath = _nodePath.default.resolve(_const.sandboxDir, (0, _lodash.uniqueId)("backup"));
+    try {
+        // We store a backup in case there's an error.
+        if (emailLayoutDirCtx.exists) {
+            await _fsExtra.copy(emailLayoutDirCtx.abspath, backupDirPath);
+            await _fsExtra.emptyDir(emailLayoutDirCtx.abspath);
+        }
+        const promises = Object.entries(bundle).map(([relpath, fileContent])=>{
+            const filePath = _nodePath.default.resolve(emailLayoutDirCtx.abspath, relpath);
+            return relpath === _helpers1.LAYOUT_JSON ? _fsExtra.outputJson(filePath, fileContent, {
+                spaces: _json.DOUBLE_SPACES
+            }) : _fsExtra.outputFile(filePath, fileContent);
+        });
+        await Promise.all(promises);
+    } catch (error) {
+        // In case of any error, wipe the target directory that is likely in a bad
+        // state then restore the backup if one existed before.
+        if (emailLayoutDirCtx.exists) {
+            await _fsExtra.emptyDir(emailLayoutDirCtx.abspath);
+            await _fsExtra.copy(backupDirPath, emailLayoutDirCtx.abspath);
+        } else {
+            await _fsExtra.remove(emailLayoutDirCtx.abspath);
+        }
+        throw error;
+    } finally{
+        // Always clean up the backup directory in the temp sandbox.
+        await _fsExtra.remove(backupDirPath);
+    }
+};
+/* For a given email layout payload, this function builds a "email layout directoy bundle".
+ * This is an object which contains all the relative paths and its file content.
+ * It includes the extractable fields, which are extracted out and added to the bundle as separate files.
+ */ const buildEmailLayoutDirBundle = (remoteEmailLayout, localEmailLayout = {})=>{
+    const bundle = {};
+    const mutRemoteEmailLayout = (0, _lodash.cloneDeep)(remoteEmailLayout);
+    // A map of extraction settings of every field in the email layout
+    const compiledExtractionSettings = compileExtractionSettings(mutRemoteEmailLayout);
+    // Iterate through each extractable field, determine whether we need to
+    // extract the field content, and if so, perform the
+    // extraction.
+    for (const [objPathParts, extractionSettings] of compiledExtractionSettings){
+        // If this layout doesn't have this field path, then we don't extract.
+        if (!(0, _lodash.has)(mutRemoteEmailLayout, objPathParts)) continue;
+        // If the field at this path is extracted in the local layout, then
+        // always extract; otherwise extract based on the field settings default.
+        const objPathStr = _object.ObjPath.stringify(objPathParts);
+        const extractedFilePath = (0, _lodash.get)(localEmailLayout, `${objPathStr}${_helpers.FILEPATH_MARKER}`);
+        const { default: extractByDefault , file_ext: fileExt  } = extractionSettings;
+        if (!extractedFilePath && !extractByDefault) continue;
+        // By this point, we have a field where we need to extract its content.
+        const data = (0, _lodash.get)(mutRemoteEmailLayout, objPathParts);
+        const fileName = objPathParts.pop();
+        // If we have an extracted file path from the local layout, we use that. In the other
+        // case we use the default path.
+        const relpath = typeof extractedFilePath === "string" ? extractedFilePath : `${fileName}.${fileExt}`;
+        // Perform the extraction by adding the content and its file path to the
+        // bundle for writing to the file system later. Then replace the field
+        // content with the extracted file path and mark the field as extracted
+        // with @ suffix.
+        (0, _lodash.set)(bundle, [
+            relpath
+        ], data);
+        (0, _lodash.set)(mutRemoteEmailLayout, `${objPathStr}${_helpers.FILEPATH_MARKER}`, relpath);
+        (0, _lodash.unset)(mutRemoteEmailLayout, objPathStr);
+    }
+    // At this point the bundle contains all extractable files, so we finally add the layout
+    // JSON realtive path + the file content.
+    return (0, _lodash.set)(bundle, [
+        _helpers1.LAYOUT_JSON
+    ], toEmailLayoutJson(mutRemoteEmailLayout));
+};
+const writeEmailLayoutIndexDir = async (indexDirCtx, remoteEmailLayouts)=>{
+    const backupDirPath = _nodePath.default.resolve(_const.sandboxDir, (0, _lodash.uniqueId)("backup"));
+    try {
+        if (indexDirCtx.exists) {
+            await _fsExtra.copy(indexDirCtx.abspath, backupDirPath);
+            await pruneLayoutsIndexDir(indexDirCtx, remoteEmailLayouts);
+        }
+        const writeEmailLayoutDirPromises = remoteEmailLayouts.map(async (remoteEmailLayout)=>{
+            const emailLayoutDirPath = _nodePath.default.resolve(indexDirCtx.abspath, remoteEmailLayout.key);
+            const emailLayoutDirCtx = {
+                type: "email_layout",
+                key: remoteEmailLayout.key,
+                abspath: emailLayoutDirPath,
+                exists: indexDirCtx.exists ? await (0, _helpers1.isEmailLayoutDir)(emailLayoutDirPath) : false
+            };
+            return writeEmailLayoutDirFromData(emailLayoutDirCtx, remoteEmailLayout);
+        });
+        await Promise.all(writeEmailLayoutDirPromises);
+    } catch (error) {
+        if (indexDirCtx.exists) {
+            await _fsExtra.emptyDir(indexDirCtx.abspath);
+            await _fsExtra.copy(backupDirPath, indexDirCtx.abspath);
+        } else {
+            await _fsExtra.remove(indexDirCtx.abspath);
+        }
+        throw error;
+    } finally{
+        // Always clean up the backup directory in the temp sandbox.
+        await _fsExtra.remove(backupDirPath);
+    }
+};
+/*
+ * Prunes the index directory by removing any files, or directories that aren't
+ * layout dirs found in fetched layouts. We want to preserve any layout
+ * dirs that are going to be updated with remote layouts, so extracted links
+ * can be respected.
+ */ const pruneLayoutsIndexDir = async (indexDirCtx, remoteEmailLayouts)=>{
+    const emailLayoutsByKey = Object.fromEntries(remoteEmailLayouts.map((e)=>[
+            e.key.toLowerCase(),
+            e
+        ]));
+    const dirents = await _fsExtra.readdir(indexDirCtx.abspath, {
+        withFileTypes: true
+    });
+    const promises = dirents.map(async (dirent)=>{
+        const direntName = dirent.name.toLowerCase();
+        const direntPath = _nodePath.default.resolve(indexDirCtx.abspath, direntName);
+        if (await (0, _helpers1.isEmailLayoutDir)(direntPath) && emailLayoutsByKey[direntName]) {
+            return;
+        }
+        await _fsExtra.remove(direntPath);
+    });
+    await Promise.all(promises);
+};

package/dist/lib/marshal/shared/helpers.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    FILEPATH_MARKER: ()=>FILEPATH_MARKER,
+    FILEPATH_MARKED_RE: ()=>FILEPATH_MARKED_RE,
+    readExtractedFileSync: ()=>readExtractedFileSync,
+    validateExtractedFilePath: ()=>validateExtractedFilePath,
+    checkIfValidExtractedFilePathFormat: ()=>checkIfValidExtractedFilePathFormat
+});
+const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
+const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
+const _error = require("../../helpers/error");
+const _json = require("../../helpers/json");
+const _liquid = require("../../helpers/liquid");
+const _workflow = require("../workflow");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const FILEPATH_MARKER = "@";
+const FILEPATH_MARKED_RE = new RegExp(`${FILEPATH_MARKER}$`);
+// The following files are exepected to have valid json content, and should be
+// decoded and joined into the main JSON file.
+const DECODABLE_JSON_FILES = new Set([
+    _workflow.VISUAL_BLOCKS_JSON
+]);
+const readExtractedFileSync = (relpath, dirCtx, objPathToFieldStr = "")=>{
+    // Check if the file actually exists at the given file path.
+    const abspath = _nodePath.resolve(dirCtx.abspath, relpath);
+    const exists = _fsExtra.pathExistsSync(abspath);
+    if (!exists) {
+        const error = new _error.JsonDataError("must be a relative path string to a file that exists", objPathToFieldStr);
+        return [
+            undefined,
+            error
+        ];
+    }
+    // Read the file and check for valid liquid syntax given it is supported
+    // across all message templates and file extensions.
+    const contentStr = _fsExtra.readFileSync(abspath, "utf8");
+    const liquidParseError = (0, _liquid.validateLiquidSyntax)(contentStr);
+    if (liquidParseError) {
+        const error = new _error.JsonDataError(`points to a file that contains invalid liquid syntax (${relpath})\n\n` + (0, _error.formatErrors)([
+            liquidParseError
+        ], {
+            indentBy: 2
+        }), objPathToFieldStr);
+        return [
+            undefined,
+            error
+        ];
+    }
+    // If the file is expected to contain decodable json, then parse the contentStr
+    // as such.
+    const fileName = _nodePath.basename(abspath.toLowerCase());
+    const decodable = DECODABLE_JSON_FILES.has(fileName);
+    const [content, jsonParseErrors] = decodable ? (0, _json.parseJson)(contentStr) : [
+        contentStr,
+        []
+    ];
+    if (jsonParseErrors.length > 0) {
+        const error = new _error.JsonDataError(`points to a file with invalid content (${relpath})\n\n` + (0, _error.formatErrors)(jsonParseErrors, {
+            indentBy: 2
+        }), objPathToFieldStr);
+        return [
+            undefined,
+            error
+        ];
+    }
+    return [
+        content,
+        undefined
+    ];
+};
+const validateExtractedFilePath = (val, sourceFileAbspath, uniqueFilePaths, objPathToFieldStr)=>{
+    // Validate the file path format, and that it is unique per entity.
+    if (!checkIfValidExtractedFilePathFormat(val, sourceFileAbspath) || typeof val !== "string" || val in uniqueFilePaths) {
+        const error = new _error.JsonDataError("must be a relative path string to a unique file within the directory", objPathToFieldStr);
+        return error;
+    }
+    // Keep track of all the valid extracted file paths that have been seen, so
+    // we can validate each file path's uniqueness as we traverse.
+    uniqueFilePaths[val] = true;
+    return undefined;
+};
+const checkIfValidExtractedFilePathFormat = (relpath, sourceFileAbspath)=>{
+    if (typeof relpath !== "string") return false;
+    if (_nodePath.isAbsolute(relpath)) return false;
+    const extractedFileAbspath = _nodePath.resolve(sourceFileAbspath, relpath);
+    const pathDiff = _nodePath.relative(sourceFileAbspath, extractedFileAbspath);
+    return !pathDiff.startsWith("..");
+};

package/dist/lib/marshal/workflow/generator.js

@@ -15,7 +15,8 @@ _export(exports, {
 });
 const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
 const _lodash = require("lodash");
-const _helpers = require("./helpers");
+const _helpers = require("../shared/helpers");
+const _helpers1 = require("./helpers");
 const _types = require("./types");
 const _writer = require("./writer");
 function _getRequireWildcardCache(nodeInterop) {
@@ -80,6 +81,7 @@ const scaffoldBatchStep = (refSuffix)=>{
         type: _types.StepType.Batch,
         settings: {
             batch_order: "asc",
+            batch_window_type: "sliding",
             batch_window: {
                 unit: "seconds",
                 value: 30
@@ -262,7 +264,7 @@ const scaffoldWorkflowDirBundle = (attrs)=>{
         steps: scaffoldedSteps
     };
     return (0, _lodash.assign)({
-        [_helpers.WORKFLOW_JSON]: workflowJson
+        [_helpers1.WORKFLOW_JSON]: workflowJson
     }, ...bundleFragments);
 };
 const generateWorkflowDir = async (workflowDirCtx, attrs)=>{

package/dist/lib/marshal/workflow/helpers.js

@@ -12,15 +12,14 @@ _export(exports, {
     WORKFLOW_JSON: ()=>WORKFLOW_JSON,
     VISUAL_BLOCKS_JSON: ()=>VISUAL_BLOCKS_JSON,
     workflowJsonPath: ()=>workflowJsonPath,
-    FILEPATH_MARKER: ()=>FILEPATH_MARKER,
-    FILEPATH_MARKED_RE: ()=>FILEPATH_MARKED_RE,
     validateWorkflowKey: ()=>validateWorkflowKey,
     lsWorkflowJson: ()=>lsWorkflowJson,
     isWorkflowDir: ()=>isWorkflowDir,
     formatCategories: ()=>formatCategories,
     formatStepSummary: ()=>formatStepSummary,
     formatStatus: ()=>formatStatus,
-    ensureValidCommandTarget: ()=>ensureValidCommandTarget
+    ensureValidCommandTarget: ()=>ensureValidCommandTarget,
+    countSteps: ()=>countSteps
 });
 const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
 const _core = require("@oclif/core");
@@ -70,8 +69,6 @@ function _interopRequireWildcard(obj, nodeInterop) {
 const WORKFLOW_JSON = "workflow.json";
 const VISUAL_BLOCKS_JSON = "visual_blocks.json";
 const workflowJsonPath = (workflowDirCtx)=>_nodePath.resolve(workflowDirCtx.abspath, WORKFLOW_JSON);
-const FILEPATH_MARKER = "@";
-const FILEPATH_MARKED_RE = new RegExp(`${FILEPATH_MARKER}$`);
 const validateWorkflowKey = (input)=>{
     if (!(0, _string.checkSlugifiedFormat)(input, {
         onlyLowerCase: true
@@ -106,14 +103,37 @@ const formatCategories = (workflow, opts = {})=>{
 };
 const batchStepSummaryLines = (step)=>{
     if (step.type !== _types.StepType.Batch) return [];
-    const { batch_key , batch_window: duration , batch_until_field_path: field_path , batch_order  } = step.settings;
+    const { batch_key , batch_window_type , batch_window: duration , batch_window_extension_limit , batch_until_field_path: field_path , batch_order  } = step.settings;
     return [
         batch_key && `Batch key: ${batch_key}`,
         duration && `Batch window: ${duration.value} ${duration.unit}`,
         field_path && `Batch window: "${field_path}"`,
+        `Batch window type: ${batch_window_type}`,
+        batch_window_extension_limit && `Batch window extension limit: ${batch_window_extension_limit.value} ${batch_window_extension_limit.unit}`,
         `Batch order: ${batch_order}`
     ];
 };
+const throttleStepSummaryLines = (step)=>{
+    if (step.type !== _types.StepType.Throttle) return [];
+    const { throttle_key , throttle_window: duration , throttle_window_field_path: field_path , throttle_limit  } = step.settings;
+    return [
+        throttle_key && `Throttle key: ${throttle_key}`,
+        duration && `Throttle window: ${duration.value} ${duration.unit}`,
+        field_path && `Throttle window: "${field_path}"`,
+        `Throttle limit: ${throttle_limit}`
+    ];
+};
+const branchStepSummaryLines = (step)=>{
+    if (step.type !== _types.StepType.Branch) return [];
+    let stepsCount = 0;
+    for (const branch of step.branches){
+        stepsCount += doCountSteps(branch.steps);
+    }
+    return [
+        `Branches: ${step.branches.length}`,
+        `Steps: ${stepsCount}`
+    ];
+};
 const delayStepSummaryLines = (step)=>{
     if (step.type !== _types.StepType.Delay) return [];
     const { delay_for: duration , delay_until_field_path: field_path  } = step.settings;
@@ -145,6 +165,8 @@ const formatStepSummary = (step)=>{
         ...batchStepSummaryLines(step),
         ...delayStepSummaryLines(step),
         ...httpFetchStepSummaryLines(step),
+        ...branchStepSummaryLines(step),
+        ...throttleStepSummaryLines(step),
         // Extra line between step rows to make it easier on the eye.
         " "
     ].filter((x)=>x);
@@ -211,3 +233,16 @@ const ensureValidCommandTarget = async (props, runContext)=>{
     }
     return _core.ux.error("Missing 1 required arg:\nworkflowKey");
 };
+const doCountSteps = (steps)=>{
+    let count = 0;
+    for (const step of steps){
+        count += 1;
+        if (step.type === _types.StepType.Branch) {
+            for (const branch of step.branches){
+                count += doCountSteps(branch.steps);
+            }
+        }
+    }
+    return count;
+};
+const countSteps = (workflow)=>doCountSteps(workflow.steps);

package/dist/lib/marshal/workflow/reader.js

@@ -10,9 +10,7 @@ function _export(target, all) {
 }
 _export(exports, {
     readWorkflowDir: ()=>readWorkflowDir,
-    readAllForCommandTarget: ()=>readAllForCommandTarget,
-    checkIfValidExtractedFilePathFormat: ()=>checkIfValidExtractedFilePathFormat,
-    readExtractedFileSync: ()=>readExtractedFileSync
+    readAllForCommandTarget: ()=>readAllForCommandTarget
 });
 const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
 const _core = require("@oclif/core");
@@ -20,9 +18,9 @@ const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
 const _lodash = require("lodash");
 const _error = require("../../helpers/error");
 const _json = require("../../helpers/json");
-const _liquid = require("../../helpers/liquid");
 const _object = require("../../helpers/object");
-const _helpers = require("./helpers");
+const _helpers = require("../shared/helpers");
+const _helpers1 = require("./helpers");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -65,102 +63,6 @@ function _interopRequireWildcard(obj, nodeInterop) {
 // For now we support up to two levels of content extraction in workflow.json.
 // (e.g. workflow.json, then visual_blocks.json)
 const MAX_EXTRACTION_LEVEL = 2;
-// The following files are exepected to have valid json content, and should be
-// decoded and joined into the main workflow.json.
-const DECODABLE_JSON_FILES = new Set([
-    _helpers.VISUAL_BLOCKS_JSON
-]);
-/*
- * Validate the file path format of an extracted field. The file path must be:
- *
- * 1) Expressed as a relative path.
- *
- *    For exmaple:
- *      subject@: "email_1/subject.html"              // GOOD
- *      subject@: "./email_1/subject.html"            // GOOD
- *      subject@: "/workflow-x/email_1/subject.html"  // BAD
- *
- * 2) The resolved path must be contained inside the workflow directory
- *
- *    For exmaple (workflow-y is a different workflow dir in this example):
- *      subject@: "./email_1/subject.html"              // GOOD
- *      subject@: "../workflow-y/email_1/subject.html"  // BAD
- *
- * Note: does not validate the presence of the file nor the uniqueness of the
- * file path.
- */ const checkIfValidExtractedFilePathFormat = (relpath, sourceFileAbspath)=>{
-    if (typeof relpath !== "string") return false;
-    if (_nodePath.isAbsolute(relpath)) return false;
-    const extractedFileAbspath = _nodePath.resolve(sourceFileAbspath, relpath);
-    const pathDiff = _nodePath.relative(sourceFileAbspath, extractedFileAbspath);
-    return !pathDiff.startsWith("..");
-};
-/*
- * Validate the extracted file path based on its format and uniqueness (but not
- * the presence).
- *
- * Note, the uniqueness check is based on reading from and writing to
- * uniqueFilePaths, which is MUTATED in place.
- */ const validateExtractedFilePath = (val, workflowDirCtx, uniqueFilePaths, objPathToFieldStr)=>{
-    const workflowJsonPath = _nodePath.resolve(workflowDirCtx.abspath, _helpers.WORKFLOW_JSON);
-    // Validate the file path format, and that it is unique per workflow.
-    if (!checkIfValidExtractedFilePathFormat(val, workflowJsonPath) || typeof val !== "string" || val in uniqueFilePaths) {
-        const error = new _error.JsonDataError("must be a relative path string to a unique file within the directory", objPathToFieldStr);
-        return error;
-    }
-    // Keep track of all the valid extracted file paths that have been seen, so
-    // we can validate each file path's uniqueness as we traverse.
-    uniqueFilePaths[val] = true;
-    return undefined;
-};
-const readExtractedFileSync = (relpath, workflowDirCtx, objPathToFieldStr = "")=>{
-    // Check if the file actually exists at the given file path.
-    const abspath = _nodePath.resolve(workflowDirCtx.abspath, relpath);
-    const exists = _fsExtra.pathExistsSync(abspath);
-    if (!exists) {
-        const error = new _error.JsonDataError("must be a relative path string to a file that exists", objPathToFieldStr);
-        return [
-            undefined,
-            error
-        ];
-    }
-    // Read the file and check for valid liquid syntax given it is supported
-    // across all message templates and file extensions.
-    const contentStr = _fsExtra.readFileSync(abspath, "utf8");
-    const liquidParseError = (0, _liquid.validateLiquidSyntax)(contentStr);
-    if (liquidParseError) {
-        const error = new _error.JsonDataError(`points to a file that contains invalid liquid syntax (${relpath})\n\n` + (0, _error.formatErrors)([
-            liquidParseError
-        ], {
-            indentBy: 2
-        }), objPathToFieldStr);
-        return [
-            undefined,
-            error
-        ];
-    }
-    // If the file is expected to contain decodable json, then parse the contentStr
-    // as such.
-    const fileName = _nodePath.basename(abspath.toLowerCase());
-    const decodable = DECODABLE_JSON_FILES.has(fileName);
-    const [content, jsonParseErrors] = decodable ? (0, _json.parseJson)(contentStr) : [
-        contentStr,
-        []
-    ];
-    if (jsonParseErrors.length > 0) {
-        const error = new _error.JsonDataError(`points to a file with invalid content (${relpath})\n\n` + (0, _error.formatErrors)(jsonParseErrors, {
-            indentBy: 2
-        }), objPathToFieldStr);
-        return [
-            undefined,
-            error
-        ];
-    }
-    return [
-        content,
-        undefined
-    ];
-};
 const joinExtractedFiles = async (workflowDirCtx, workflowJson)=>{
     // Tracks any errors encountered during traversal. Mutated in place.
     const errors = [];
@@ -192,7 +94,7 @@ const joinExtractedFiles = async (workflowDirCtx, workflowJson)=>{
             const lastFound = (0, _object.getLastFound)(prevJoinedFilePaths, parts);
             const prevJoinedFilePath = typeof lastFound === "string" ? lastFound : undefined;
             const rebasedFilePath = prevJoinedFilePath ? _nodePath.join(_nodePath.dirname(prevJoinedFilePath), value) : value;
-            const invalidFilePathError = validateExtractedFilePath(rebasedFilePath, workflowDirCtx, uniqueFilePaths, objPathToFieldStr);
+            const invalidFilePathError = (0, _helpers.validateExtractedFilePath)(rebasedFilePath, _nodePath.resolve(workflowDirCtx.abspath, _helpers1.WORKFLOW_JSON), uniqueFilePaths, objPathToFieldStr);
             if (invalidFilePathError) {
                 errors.push(invalidFilePathError);
                 // Wipe the invalid file path in the node so the final workflow json
@@ -206,7 +108,7 @@ const joinExtractedFiles = async (workflowDirCtx, workflowJson)=>{
             }
             // By this point we have a valid extracted file path, so attempt to read
             // the file at the file path.
-            const [content, readExtractedFileError] = readExtractedFileSync(rebasedFilePath, workflowDirCtx, objPathToFieldStr);
+            const [content, readExtractedFileError] = (0, _helpers.readExtractedFileSync)(rebasedFilePath, workflowDirCtx, objPathToFieldStr);
             if (readExtractedFileError) {
                 errors.push(readExtractedFileError);
                 // Replace the extracted file path with the rebased one, and set the
@@ -236,7 +138,7 @@ const readWorkflowDir = async (workflowDirCtx, opts = {})=>{
     const { withExtractedFiles =false , withReadonlyField =false  } = opts;
     const dirExists = await _fsExtra.pathExists(abspath);
     if (!dirExists) throw new Error(`${abspath} does not exist`);
-    const workflowJsonPath = await (0, _helpers.lsWorkflowJson)(abspath);
+    const workflowJsonPath = await (0, _helpers1.lsWorkflowJson)(abspath);
     if (!workflowJsonPath) throw new Error(`${abspath} is not a workflow directory`);
     const result = await (0, _json.readJson)(workflowJsonPath);
     if (!result[0]) return result;
@@ -259,7 +161,7 @@ const readWorkflowDir = async (workflowDirCtx, opts = {})=>{
         // eslint-disable-next-line no-await-in-loop
         const [workflow, readErrors] = await readWorkflowDir(workflowDirCtx, opts);
         if (readErrors.length > 0) {
-            const workflowJsonPath = _nodePath.resolve(workflowDirCtx.abspath, _helpers.WORKFLOW_JSON);
+            const workflowJsonPath = _nodePath.resolve(workflowDirCtx.abspath, _helpers1.WORKFLOW_JSON);
             const e = new _error.SourceError((0, _error.formatErrors)(readErrors), workflowJsonPath);
             errors.push(e);
             continue;
@@ -298,7 +200,7 @@ const readAllForCommandTarget = async (target, opts = {})=>{
                         type: "workflow",
                         key: dirent.name,
                         abspath,
-                        exists: await (0, _helpers.isWorkflowDir)(abspath)
+                        exists: await (0, _helpers1.isWorkflowDir)(abspath)
                     };
                     return workflowDirCtx;
                 });

package/dist/lib/marshal/workflow/types.js

@@ -12,4 +12,6 @@ var StepType;
     StepType["Batch"] = "batch";
     StepType["Delay"] = "delay";
     StepType["HttpFetch"] = "http_fetch";
+    StepType["Branch"] = "branch";
+    StepType["Throttle"] = "throttle";
 })(StepType || (StepType = {}));