@knocklabs/cli 0.1.0-rc.2 → 0.1.0-rc.4

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

@@ -9,9 +9,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    validateTemplateFilePathFormat: ()=>validateTemplateFilePathFormat,
     readWorkflowDir: ()=>readWorkflowDir,
-    readTemplateFile: ()=>readTemplateFile
+    checkIfValidExtractedFilePathFormat: ()=>checkIfValidExtractedFilePathFormat,
+    readExtractedFileSync: ()=>readExtractedFileSync
 });
 const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
 const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
@@ -21,7 +21,6 @@ const _json = require("../../helpers/json");
 const _liquid = require("../../helpers/liquid");
 const _object = require("../../helpers/object");
 const _helpers = require("./helpers");
-const _types = require("./types");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -61,66 +60,95 @@ function _interopRequireWildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-const validateTemplateFilePathFormat = (relpath, workflowDirCtx)=>{
+// 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 abspath = _nodePath.resolve(workflowDirCtx.abspath, relpath);
-    const pathDiff = _nodePath.relative(workflowDirCtx.abspath, abspath);
+    const extractedFileAbspath = _nodePath.resolve(sourceFileAbspath, relpath);
+    const pathDiff = _nodePath.relative(sourceFileAbspath, extractedFileAbspath);
     return !pathDiff.startsWith("..");
 };
 /*
- * Validate that a file exists at the given relative path in the directory.
- */ const validateTemplateFileExists = async (relpath, workflowDirCtx)=>{
-    const abspath = _nodePath.resolve(workflowDirCtx.abspath, relpath);
-    return _fsExtra.pathExists(abspath);
+ * 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 readTemplateFile = async (relpath, workflowDirCtx)=>{
+const readExtractedFileSync = (relpath, workflowDirCtx, objPathToFieldStr = "")=>{
+    // Check if the file actually exists at the given file path.
     const abspath = _nodePath.resolve(workflowDirCtx.abspath, relpath);
-    // First read all template files as text content and check for valid liquid
-    // syntax given it is supported across all message templates and formats.
-    const content = await _fsExtra.readFile(abspath, "utf8");
-    const liquidParseError = (0, _liquid.validateLiquidSyntax)(content);
-    return liquidParseError ? [
-        undefined,
-        [
-            liquidParseError
-        ]
-    ] : [
-        content,
-        []
-    ];
-};
-/*
- * Validates that a given value is a valid template file path and the file
- * actually exists, before reading the file content.
- */ const maybeReadTemplateFile = async (val, workflowDirCtx, extractedFilePaths, pathToFieldStr)=>{
-    // Validate the file path format, and that it is unique per workflow.
-    if (!validateTemplateFilePathFormat(val, workflowDirCtx) || typeof val !== "string" || val in extractedFilePaths) {
-        const error = new _error.JsonDataError("must be a relative path string to a unique file within the directory", pathToFieldStr);
+    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
         ];
     }
-    // Keep track of all the extracted file paths that have been seen, so we
-    // can validate each file path's uniqueness as we traverse.
-    extractedFilePaths[val] = true;
-    // Check a file actually exists at the given file path.
-    const exists = await validateTemplateFileExists(val, workflowDirCtx);
-    if (!exists) {
-        const error = new _error.JsonDataError("must be a relative path string to a file that exists", pathToFieldStr);
+    // 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
         ];
     }
-    // Read the template file and inline the content into the workflow json
-    // under the same field name but without the @ filepath marker.
-    const [content, contentErrors] = await readTemplateFile(val, workflowDirCtx);
-    if (contentErrors.length > 0) {
-        const error = new _error.JsonDataError(`points to a file with invalid content (${val})\n\n` + (0, _error.formatErrors)(contentErrors, {
+    // 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
-        }), pathToFieldStr);
+        }), objPathToFieldStr);
         return [
             undefined,
             error
@@ -131,79 +159,70 @@ const readTemplateFile = async (relpath, workflowDirCtx)=>{
         undefined
     ];
 };
-const compileTemplateFiles = async (workflowDirCtx, workflowJson)=>{
+const joinExtractedFiles = async (workflowDirCtx, workflowJson)=>{
+    // Tracks any errors encountered during traversal. Mutated in place.
     const errors = [];
-    const extractedFilePaths = {};
-    const objPath = new _object.ObjPath();
-    // 1. Make sure we have a list of steps to look through.
-    if (workflowJson.steps === undefined) {
-        return [
-            workflowJson,
-            errors
-        ];
-    }
-    if (!Array.isArray(workflowJson.steps)) {
-        errors.push(new _error.JsonDataError("must be an array of workflow steps", objPath.to("steps").str));
-        return [
-            workflowJson,
-            errors
-        ];
-    }
-    // 2. Make sure we can reach `steps[i].template` for channel steps.
-    const steps = workflowJson.steps || [];
-    const pathToSteps = objPath.push("steps").checkout();
-    for (const [stepIdx, step] of steps.entries()){
-        objPath.reset(pathToSteps).push(stepIdx);
-        if (!(0, _lodash.isPlainObject)(step)) {
-            errors.push(new _error.JsonDataError("must be a workflow step object", objPath.str));
-            continue;
-        }
-        if (step.type === undefined) {
-            errors.push(new _error.JsonDataError("must have a `type` field", objPath.str));
-            continue;
-        }
-        // Not a channel step, nothing more to do.
-        if (step.type !== _types.StepType.Channel) {
-            continue;
-        }
-        if (step.template === undefined) {
-            errors.push(new _error.JsonDataError("must have a `template` field containing a template object", objPath.str));
-            continue;
-        }
-        if (!(0, _lodash.isPlainObject)(step.template)) {
-            errors.push(new _error.JsonDataError("must be a template object", objPath.to("template").str));
-            continue;
-        }
-        // 3. For a given template, look for any extracted template content, read
-        // the extracted template files, then inline the content.
-        objPath.push("template");
-        for (const [field, val] of Object.entries(step.template)){
-            if (field.startsWith("settings")) continue;
-            if (!_helpers.FILEPATH_MARKED_RE.test(field)) continue;
-            const pathToFieldStr = objPath.to(field).str;
-            // eslint-disable-next-line no-await-in-loop
-            const [content, error] = await maybeReadTemplateFile(val, workflowDirCtx, extractedFilePaths, pathToFieldStr);
-            if (error) {
-                errors.push(error);
-                continue;
+    // Tracks each new valid extracted file path seen (rebased to be relative to
+    // workflow.json) in the workflow json node. Mutated in place, and used
+    // to validate the uniqueness of an extracted path encountered.
+    const uniqueFilePaths = {};
+    // Tracks each extracted file path (rebased) that gets inlined with its object
+    // path location, per each traversal iteration. Mutated in place, and used for
+    // rebasing an extracted path to be relative to the location of the workflow
+    // json file.
+    const joinedFilePathsPerLevel = [];
+    for (const [idx] of Array.from({
+        length: MAX_EXTRACTION_LEVEL
+    }).entries()){
+        const currJoinedFilePaths = {};
+        const prevJoinedFilePaths = joinedFilePathsPerLevel[idx - 1] || {};
+        (0, _object.mapValuesDeep)(workflowJson, (value, key, parts)=>{
+            // If not marked with the @ suffix, there's nothing to do.
+            if (!_helpers.FILEPATH_MARKED_RE.test(key)) return;
+            const objPathToFieldStr = _object.ObjPath.stringify(parts);
+            const inlinObjPathStr = objPathToFieldStr.replace(_helpers.FILEPATH_MARKED_RE, "");
+            // If there is inlined content present already, then nothing more to do.
+            if ((0, _lodash.hasIn)(workflowJson, inlinObjPathStr)) return;
+            // Check if the extracted path found at the current field path belongs to
+            // a node whose parent or grandparent has been previously joined earlier
+            // in the tree. If so, rebase the extracted path to be a relative path to
+            // the workflow json.
+            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);
+            if (invalidFilePathError) {
+                errors.push(invalidFilePathError);
+                // Wipe the invalid file path in the node so the final workflow json
+                // object ends up with only valid file paths, this way workflow writer
+                // can see only valid file paths and use those when pulling. Also set
+                // the inlined field path in workflow object with empty content so we
+                // know we've looked at this extracted file path.
+                (0, _lodash.set)(workflowJson, objPathToFieldStr, undefined);
+                (0, _lodash.set)(workflowJson, inlinObjPathStr, undefined);
+                return;
             }
-            const inlinePathStr = pathToFieldStr.replace(_helpers.FILEPATH_MARKED_RE, "");
-            (0, _lodash.set)(workflowJson, inlinePathStr, content);
-        }
-        if (!step.template.settings) continue;
-        objPath.push("settings");
-        for (const [field, val] of Object.entries(step.template.settings)){
-            if (!_helpers.FILEPATH_MARKED_RE.test(field)) continue;
-            const pathToFieldStr = objPath.to(field).str;
-            // eslint-disable-next-line no-await-in-loop
-            const [content, error] = await maybeReadTemplateFile(val, workflowDirCtx, extractedFilePaths, pathToFieldStr);
-            if (error) {
-                errors.push(error);
-                continue;
+            // 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);
+            if (readExtractedFileError) {
+                errors.push(readExtractedFileError);
+                // Replace the extracted file path with the rebased one, and set the
+                // inlined field path in workflow object with empty content, so we know
+                // we do not need to try inlining again.
+                (0, _lodash.set)(workflowJson, objPathToFieldStr, rebasedFilePath);
+                (0, _lodash.set)(workflowJson, inlinObjPathStr, undefined);
+                return;
             }
-            const inlinePathStr = pathToFieldStr.replace(_helpers.FILEPATH_MARKED_RE, "");
-            (0, _lodash.set)(workflowJson, inlinePathStr, content);
-        }
+            // Inline the file content and replace the extracted file path with a
+            // rebased one.
+            (0, _lodash.set)(workflowJson, objPathToFieldStr, rebasedFilePath);
+            (0, _lodash.set)(workflowJson, inlinObjPathStr, content);
+            // Track joined file paths from the current join level.
+            (0, _lodash.set)(currJoinedFilePaths, inlinObjPathStr, rebasedFilePath);
+        });
+        // Finally save all the joined file paths from this traversal iteration.
+        joinedFilePathsPerLevel[idx] = currJoinedFilePaths;
     }
     return [
         workflowJson,
@@ -212,7 +231,7 @@ const compileTemplateFiles = async (workflowDirCtx, workflowJson)=>{
 };
 const readWorkflowDir = async (workflowDirCtx, opts = {})=>{
     const { abspath  } = workflowDirCtx;
-    const { withTemplateFiles =false , withReadonlyField =false  } = 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);
@@ -223,7 +242,7 @@ const readWorkflowDir = async (workflowDirCtx, opts = {})=>{
     workflowJson = withReadonlyField ? workflowJson : (0, _object.omitDeep)(workflowJson, [
         "__readonly"
     ]);
-    return withTemplateFiles ? compileTemplateFiles(workflowDirCtx, workflowJson) : [
+    return withExtractedFiles ? joinExtractedFiles(workflowDirCtx, workflowJson) : [
         workflowJson,
         []
     ];