@knocklabs/cli 0.1.18 → 0.1.20

package/dist/lib/marshal/partial/writer.js

@@ -0,0 +1,175 @@
+"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, {
+    prunePartialsIndexDir: function() {
+        return prunePartialsIndexDir;
+    },
+    writePartialDirFromData: function() {
+        return writePartialDirFromData;
+    },
+    writePartialsIndexDir: function() {
+        return writePartialsIndexDir;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _lodash = require("lodash");
+const _const = require("../../helpers/const");
+const _json = require("../../helpers/json");
+const _helpers = require("./helpers");
+const _processorisomorphic = require("./processor.isomorphic");
+const _reader = require("./reader");
+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 _interop_require_wildcard(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 = {
+        __proto__: null
+    };
+    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 writePartialDirFromData = async (partialDirCtx, remotePartial)=>{
+    // If the partial directory exists on the file system (i.e. previously
+    // pulled before), then read the partial file to use as a reference.
+    const [localPartial] = partialDirCtx.exists ? await (0, _reader.readPartialDir)(partialDirCtx, {
+        withExtractedFiles: true
+    }) : [];
+    const bundle = (0, _processorisomorphic.buildPartialDirBundle)(remotePartial, localPartial);
+    return writePartialDirFromBundle(partialDirCtx, bundle);
+};
+/*
+ * A lower level write function that takes a constructed partial dir bundle
+ * and writes it into a partial directory on a local file system.
+ *
+ * It does not make any assumptions about how the partial directory bundle was
+ * built; for example, it can be from parsing the partial data fetched from
+ * the Knock API, or built manually for scaffolding purposes.
+ */ const writePartialDirFromBundle = async (partialDirCtx, partialDirBundle)=>{
+    const backupDirPath = _nodepath.resolve(_const.sandboxDir, (0, _lodash.uniqueId)("backup"));
+    try {
+        if (partialDirCtx.exists) {
+            await _fsextra.copy(partialDirCtx.abspath, backupDirPath);
+            await _fsextra.emptyDir(partialDirCtx.abspath);
+        }
+        const promises = Object.entries(partialDirBundle).map(([relpath, fileContent])=>{
+            const filePath = _nodepath.resolve(partialDirCtx.abspath, relpath);
+            return relpath === _processorisomorphic.PARTIAL_JSON ? _fsextra.outputJson(filePath, fileContent, {
+                spaces: _json.DOUBLE_SPACES
+            }) : _fsextra.outputFile(filePath, fileContent !== null && fileContent !== void 0 ? 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 (partialDirCtx.exists) {
+            await _fsextra.emptyDir(partialDirCtx.abspath);
+            await _fsextra.copy(backupDirPath, partialDirCtx.abspath);
+        } else {
+            await _fsextra.remove(partialDirCtx.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
+ * partial dirs found in fetched partials. We want to preserve any partial
+ * dirs that are going to be updated with remote partials, so extracted links
+ * can be respected.
+ */ const prunePartialsIndexDir = async (indexDirCtx, remotePartials)=>{
+    const partialsByKey = Object.fromEntries(remotePartials.map((w)=>[
+            w.key.toLowerCase(),
+            w
+        ]));
+    const dirents = await _fsextra.readdir(indexDirCtx.abspath, {
+        withFileTypes: true
+    });
+    const promises = dirents.map(async (dirent)=>{
+        const direntName = dirent.name.toLowerCase();
+        const direntPath = _nodepath.resolve(indexDirCtx.abspath, direntName);
+        if (await (0, _helpers.isPartialDir)(direntPath) && partialsByKey[direntName]) {
+            return;
+        }
+        await _fsextra.remove(direntPath);
+    });
+    await Promise.all(promises);
+};
+const writePartialsIndexDir = async (indexDirCtx, remotePartials)=>{
+    const backupDirPath = _nodepath.resolve(_const.sandboxDir, (0, _lodash.uniqueId)("backup"));
+    try {
+        // If the index directory already exists, back it up in the temp sandbox
+        // before wiping it clean.
+        if (indexDirCtx.exists) {
+            await _fsextra.copy(indexDirCtx.abspath, backupDirPath);
+            await prunePartialsIndexDir(indexDirCtx, remotePartials);
+        }
+        // Write given remote partials into the given partials directory path.
+        const writePartialDirPromises = remotePartials.map(async (partial)=>{
+            const partialDirPath = _nodepath.resolve(indexDirCtx.abspath, partial.key);
+            const partialDirCtx = {
+                type: "partial",
+                key: partial.key,
+                abspath: partialDirPath,
+                exists: indexDirCtx.exists ? await (0, _helpers.isPartialDir)(partialDirPath) : false
+            };
+            return writePartialDirFromData(partialDirCtx, partial);
+        });
+        await Promise.all(writePartialDirPromises);
+    } catch (error) {
+        console.log(error);
+        // In case of any error, wipe the index directory that is likely in a bad
+        // state then restore the backup if one existed before.
+        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);
+    }
+};

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

@@ -8,12 +8,12 @@ Object.defineProperty(exports, "StepType", {
         return StepType;
     }
 });
-var StepType;
-(function(StepType) {
+var StepType = /*#__PURE__*/ function(StepType) {
     StepType["Channel"] = "channel";
     StepType["Batch"] = "batch";
     StepType["Delay"] = "delay";
     StepType["HttpFetch"] = "http_fetch";
     StepType["Branch"] = "branch";
     StepType["Throttle"] = "throttle";
-})(StepType || (StepType = {}));
+    return StepType;
+}({});

package/dist/lib/run-context/loader.js

@@ -14,6 +14,8 @@ Object.defineProperty(exports, "load", {
 });
 const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
 const _emaillayout = /*#__PURE__*/ _interop_require_wildcard(require("../marshal/email-layout"));
+const _messagetype = /*#__PURE__*/ _interop_require_wildcard(require("../marshal/message-type"));
+const _partial = /*#__PURE__*/ _interop_require_wildcard(require("../marshal/partial"));
 const _translation = /*#__PURE__*/ _interop_require_wildcard(require("../marshal/translation"));
 const _workflow = /*#__PURE__*/ _interop_require_wildcard(require("../marshal/workflow"));
 function _getRequireWildcardCache(nodeInterop) {
@@ -57,38 +59,40 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+const buildResourceDirContext = (type, currDir)=>{
+    return {
+        type,
+        key: _nodepath.basename(currDir),
+        abspath: currDir,
+        exists: true
+    };
+};
 const evaluateRecursively = async (ctx, currDir)=>{
-    // Check if we are inside a workflow directory, and if so update the context.
-    const isWorkflowDir = await _workflow.isWorkflowDir(currDir);
-    if (!ctx.resourceDir && isWorkflowDir) {
-        ctx.resourceDir = {
-            type: "workflow",
-            key: _nodepath.basename(currDir),
-            abspath: currDir,
-            exists: true
-        };
-    }
-    // Check if we are inside a layout directory, and if so update the context.
-    const isEmailLayoutDir = await _emaillayout.isEmailLayoutDir(currDir);
-    if (!ctx.resourceDir && isEmailLayoutDir) {
-        ctx.resourceDir = {
-            type: "email_layout",
-            key: _nodepath.basename(currDir),
-            abspath: currDir,
-            exists: true
-        };
-    }
-    // NOTE: Must keep this check as last in the order of directory-type checks
-    // since the `isTranslationDir` only checks that the directory name is a
-    // valid locale name.
-    const isTranslationDir = _translation.isTranslationDir(currDir);
-    if (!ctx.resourceDir && isTranslationDir) {
-        ctx.resourceDir = {
-            type: "translation",
-            key: _nodepath.basename(currDir),
-            abspath: currDir,
-            exists: true
-        };
+    // Check if we are inside a resource directory and if so update the context.
+    if (!ctx.resourceDir) {
+        const isWorkflowDir = await _workflow.isWorkflowDir(currDir);
+        if (isWorkflowDir) {
+            ctx.resourceDir = buildResourceDirContext("workflow", currDir);
+        }
+        const isEmailLayoutDir = await _emaillayout.isEmailLayoutDir(currDir);
+        if (isEmailLayoutDir) {
+            ctx.resourceDir = buildResourceDirContext("email_layout", currDir);
+        }
+        const isPartialDir = await _partial.isPartialDir(currDir);
+        if (isPartialDir) {
+            ctx.resourceDir = buildResourceDirContext("partial", currDir);
+        }
+        const isMessageTypeDir = await _messagetype.isMessageTypeDir(currDir);
+        if (isMessageTypeDir) {
+            ctx.resourceDir = buildResourceDirContext("message_type", currDir);
+        }
+        // NOTE: Must keep this check as last in the order of directory-type checks
+        // since the `isTranslationDir` only checks that the directory name is a
+        // valid locale name.
+        const isTranslationDir = _translation.isTranslationDir(currDir);
+        if (isTranslationDir) {
+            ctx.resourceDir = buildResourceDirContext("translation", currDir);
+        }
     }
     // If we've identified the resource context, no need to go further.
     // TODO: In the future, consider supporting a knock project config file which