@knocklabs/cli 0.1.3 → 0.1.5

package/dist/commands/workflow/run.js

@@ -23,26 +23,24 @@ class WorkflowRun extends _baseCommand.default {
             action: "‣ Running"
         });
         this.log(`‣ Successfully ran \`${args.workflowKey}\` workflow in \`${flags.environment}\` environment`);
-        this.log((0, _string.indentString)(`Workflow run id: ${resp.data.workflow_run_id}`), 4);
+        this.log((0, _string.indentString)(`Workflow run id: ${resp.data.workflow_run_id}`, 4));
     }
 }
-WorkflowRun.summary = "Test run a workflow using the latest version from Knock, or a local workflow directory.";
+WorkflowRun.summary = "Test run a workflow using the latest version from Knock.";
 WorkflowRun.flags = {
     environment: _core.Flags.string({
         default: "development",
         summary: "The environment in which to run the workflow"
     }),
-    recipients: _core.Flags.string({
+    recipients: (0, _flag.maybeJsonStrAsList)({
         required: true,
         aliases: [
             "recipient"
         ],
-        summary: "One or more recipient ids for this workflow run, separated by comma.",
-        multiple: true,
-        delimiter: ","
+        summary: "One or more recipient user ids separated by comma, or a JSON string containing one or more recipient object references for this workflow run."
     }),
-    actor: _core.Flags.string({
-        summary: "An actor id for the workflow run."
+    actor: (0, _flag.maybeJsonStr)({
+        summary: "An actor id, or a JSON string of an actor object reference for the workflow run."
     }),
     tenant: _core.Flags.string({
         summary: "A tenant id for the workflow run."

package/dist/lib/api-v1.js

@@ -81,13 +81,15 @@ class ApiV1 {
     }
     async runWorkflow({ args , flags  }) {
         const params = (0, _object.prune)({
-            environment: flags.environment,
+            environment: flags.environment
+        });
+        const data = (0, _object.prune)({
             recipients: flags.recipients,
             tenant: flags.tenant,
             data: flags.data,
             actor: flags.actor
         });
-        return this.put(`/workflows/${args.workflowKey}/run`, {}, {
+        return this.put(`/workflows/${args.workflowKey}/run`, data, {
             params
         });
     }
@@ -157,6 +159,53 @@ class ApiV1 {
             params
         });
     }
+    // By resources: Email layouts
+    async listEmailLayouts({ flags  }) {
+        const params = (0, _object.prune)({
+            environment: flags.environment,
+            annotate: flags.annotate,
+            hide_uncommitted_changes: flags["hide-uncommitted-changes"],
+            ...(0, _page.toPageParams)(flags)
+        });
+        return this.get("/email_layouts", {
+            params
+        });
+    }
+    async getEmailLayout({ args , flags  }) {
+        const params = (0, _object.prune)({
+            environment: flags.environment,
+            annotate: flags.annotate,
+            hide_uncommitted_changes: flags["hide-uncommitted-changes"]
+        });
+        return this.get(`/email_layouts/${args.emailLayoutKey}`, {
+            params
+        });
+    }
+    async upsertEmailLayout({ flags  }, layout) {
+        const params = (0, _object.prune)({
+            environment: flags.environment,
+            annotate: flags.annotate,
+            commit: flags.commit,
+            commit_message: flags["commit-message"]
+        });
+        const data = {
+            email_layout: layout
+        };
+        return this.put(`/email_layouts/${layout.key}`, data, {
+            params
+        });
+    }
+    async validateEmailLayout({ flags  }, layout) {
+        const params = (0, _object.prune)({
+            environment: flags.environment
+        });
+        const data = {
+            email_layout: layout
+        };
+        return this.put(`/email_layouts/${layout.key}/validate`, data, {
+            params
+        });
+    }
     // By methods:
     async get(subpath, config) {
         return this.client.get(`/${API_VERSION}` + subpath, config);

package/dist/lib/helpers/flag.js

@@ -11,11 +11,14 @@ function _export(target, all) {
 _export(exports, {
     booleanStr: ()=>booleanStr,
     dirPath: ()=>dirPath,
-    jsonStr: ()=>jsonStr
+    jsonStr: ()=>jsonStr,
+    maybeJsonStr: ()=>maybeJsonStr,
+    maybeJsonStrAsList: ()=>maybeJsonStrAsList
 });
 const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
 const _core = require("@oclif/core");
 const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
+const _json = require("./json");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -85,3 +88,18 @@ const jsonStr = _core.Flags.custom({
         }
     }
 });
+const maybeJsonStr = _core.Flags.custom({
+    parse: async (input)=>{
+        return (0, _json.tryJsonParse)(input);
+    }
+});
+const maybeJsonStrAsList = _core.Flags.custom({
+    parse: async (input)=>{
+        const data = (0, _json.tryJsonParse)(input);
+        if (typeof data === "string") return data.split(",");
+        if (Array.isArray(data)) return data;
+        return [
+            data
+        ];
+    }
+});

package/dist/lib/helpers/json.js

@@ -11,6 +11,7 @@ function _export(target, all) {
 _export(exports, {
     DOUBLE_SPACES: ()=>DOUBLE_SPACES,
     parseJson: ()=>parseJson,
+    tryJsonParse: ()=>tryJsonParse,
     readJson: ()=>readJson
 });
 const _jsonlint = /*#__PURE__*/ _interopRequireWildcard(require("@prantlf/jsonlint"));
@@ -71,6 +72,14 @@ const parseJson = (json)=>{
         errors
     ];
 };
+const tryJsonParse = (maybeJson)=>{
+    try {
+        const data = JSON.parse(maybeJson);
+        return data;
+    } catch  {
+        return maybeJson;
+    }
+};
 const readJson = async (filePath)=>{
     const json = await _fsExtra.readFile(filePath, "utf8");
     return parseJson(json);

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

@@ -0,0 +1,124 @@
+"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, {
+    LAYOUT_JSON: ()=>LAYOUT_JSON,
+    emailLayoutJsonPath: ()=>emailLayoutJsonPath,
+    isEmailLayoutDir: ()=>isEmailLayoutDir,
+    lsEmailLayoutJson: ()=>lsEmailLayoutJson,
+    ensureValidCommandTarget: ()=>ensureValidCommandTarget
+});
+const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
+const _core = require("@oclif/core");
+const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
+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 LAYOUT_JSON = "layout.json";
+const emailLayoutJsonPath = (layoutDirCtx)=>_nodePath.resolve(layoutDirCtx.abspath, LAYOUT_JSON);
+const isEmailLayoutDir = async (dirPath)=>Boolean(await lsEmailLayoutJson(dirPath));
+const lsEmailLayoutJson = async (dirPath)=>{
+    const emailLayoutJsonPath = _nodePath.resolve(dirPath, LAYOUT_JSON);
+    const exists = await _fsExtra.pathExists(emailLayoutJsonPath);
+    return exists ? emailLayoutJsonPath : undefined;
+};
+const ensureValidCommandTarget = async (props, runContext)=>{
+    const { args , flags  } = props;
+    const { commandId , resourceDir: resourceDirCtx , cwd: runCwd  } = runContext;
+    // If the target resource is a different type than the current resource dir
+    // type, error out.
+    if (resourceDirCtx && resourceDirCtx.type !== "email_layout") {
+        return _core.ux.error(`Cannot run ${commandId} inside a ${resourceDirCtx.type} directory`);
+    }
+    // Cannot accept both email layout key arg and --all flag.
+    if (flags.all && args.emailLayoutKey) {
+        return _core.ux.error(`emailLayoutKey arg \`${args.emailLayoutKey}\` cannot also be provided when using --all`);
+    }
+    // --all flag is given, which means no layout key arg.
+    if (flags.all) {
+        // If --all flag used inside a layout directory, then require a layouts dir path.
+        if (resourceDirCtx && !flags["layouts-dir"]) {
+            return _core.ux.error("Missing required flag layouts-dir");
+        }
+        // Targeting all layout dirs in the layouts index dir.
+        // TODO: Default to the knock project config first if present before cwd.
+        const defaultToCwd = {
+            abspath: runCwd,
+            exists: true
+        };
+        const indexDirCtx = flags["layouts-dir"] || defaultToCwd;
+        return {
+            type: "emailLayoutsIndexDir",
+            context: indexDirCtx
+        };
+    }
+    // Email layout key arg is given, which means no --all flag.
+    if (args.emailLayoutKey) {
+        if (resourceDirCtx && resourceDirCtx.key !== args.emailLayoutKey) {
+            return _core.ux.error(`Cannot run ${commandId} \`${args.emailLayoutKey}\` inside another layout directory:\n${resourceDirCtx.key}`);
+        }
+        const targetDirPath = resourceDirCtx ? resourceDirCtx.abspath : _nodePath.resolve(runCwd, args.emailLayoutKey);
+        const layoutDirCtx = {
+            type: "email_layout",
+            key: args.emailLayoutKey,
+            abspath: targetDirPath,
+            exists: await isEmailLayoutDir(targetDirPath)
+        };
+        return {
+            type: "emailLayoutDir",
+            context: layoutDirCtx
+        };
+    }
+    // From this point on, we have neither an email layout key arg nor --all flag.
+    // If running inside a layout directory, then use that.
+    if (resourceDirCtx) {
+        return {
+            type: "emailLayoutDir",
+            context: resourceDirCtx
+        };
+    }
+    return _core.ux.error("Missing 1 required arg:emailLayoutKey");
+};

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_exportStar(require("./helpers"), exports);
+_exportStar(require("./reader"), exports);
+_exportStar(require("./types"), exports);
+_exportStar(require("./writer"), exports);
+function _exportStar(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) Object.defineProperty(to, k, {
+            enumerable: true,
+            get: function() {
+                return from[k];
+            }
+        });
+    });
+    return from;
+}

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

@@ -0,0 +1,193 @@
+"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, {
+    readAllForCommandTarget: ()=>readAllForCommandTarget,
+    readEmailLayoutDir: ()=>readEmailLayoutDir
+});
+const _nodePath = /*#__PURE__*/ _interopRequireDefault(require("node:path"));
+const _core = require("@oclif/core");
+const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
+const _lodash = require("lodash");
+const _error = require("../../helpers/error");
+const _json = require("../../helpers/json");
+const _object = require("../../helpers/object");
+const _helpers = require("../shared/helpers");
+const _helpers1 = require("./helpers");
+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;
+}
+const readAllForCommandTarget = async (target, opts = {})=>{
+    const { type: targetType , context: targetCtx  } = target;
+    if (!targetCtx.exists) {
+        const subject = targetType === "emailLayoutDir" ? "a layout directory at" : "layout directories in";
+        return _core.ux.error(`Cannot locate ${subject} \`${targetCtx.abspath}\``);
+    }
+    switch(targetType){
+        case "emailLayoutDir":
+            {
+                return readEmailLayoutsDirs([
+                    targetCtx
+                ], opts);
+            }
+        case "emailLayoutsIndexDir":
+            {
+                const dirents = await _fsExtra.readdir(targetCtx.abspath, {
+                    withFileTypes: true
+                });
+                const promises = dirents.map(async (dirent)=>{
+                    const abspath = _nodePath.default.resolve(targetCtx.abspath, dirent.name);
+                    const layoutDirCtx = {
+                        type: "email_layout",
+                        key: dirent.name,
+                        abspath,
+                        exists: await (0, _helpers1.isEmailLayoutDir)(abspath)
+                    };
+                    return layoutDirCtx;
+                });
+                const layoutDirCtxs = (await Promise.all(promises)).filter((layoutDirCtx)=>layoutDirCtx.exists);
+                return readEmailLayoutsDirs(layoutDirCtxs, opts);
+            }
+        default:
+            throw new Error(`Invalid layout command target: ${target}`);
+    }
+};
+/*
+ * For the given list of layout directory contexts, read each layout dir and
+ * return layout directory data.
+ */ const readEmailLayoutsDirs = async (layoutDirCtxs, opts = {})=>{
+    const layouts = [];
+    const errors = [];
+    for (const layoutDirCtx of layoutDirCtxs){
+        // eslint-disable-next-line no-await-in-loop
+        const [layout, readErrors] = await readEmailLayoutDir(layoutDirCtx, opts);
+        if (readErrors.length > 0) {
+            const layoutJsonPath = _nodePath.default.resolve(layoutDirCtx.abspath, _helpers1.LAYOUT_JSON);
+            const e = new _error.SourceError((0, _error.formatErrors)(readErrors), layoutJsonPath);
+            errors.push(e);
+            continue;
+        }
+        layouts.push({
+            ...layoutDirCtx,
+            content: layout
+        });
+    }
+    return [
+        layouts,
+        errors
+    ];
+};
+const readEmailLayoutDir = async (layoutDirCtx, opts = {})=>{
+    const { abspath  } = layoutDirCtx;
+    const { withExtractedFiles =false , withReadonlyField =false  } = opts;
+    const dirExists = await _fsExtra.pathExists(abspath);
+    if (!dirExists) throw new Error(`${abspath} does not exist`);
+    const layoutJsonPath = await (0, _helpers1.lsEmailLayoutJson)(abspath);
+    if (!layoutJsonPath) throw new Error(`${abspath} is not a layout directory`);
+    const result = await (0, _json.readJson)(layoutJsonPath);
+    if (!result[0]) return result;
+    let [layoutJson] = result;
+    layoutJson = withReadonlyField ? layoutJson : (0, _object.omitDeep)(layoutJson, [
+        "__readonly"
+    ]);
+    return withExtractedFiles ? joinExtractedFiles(layoutDirCtx, layoutJson) : [
+        layoutJson,
+        []
+    ];
+};
+/*
+ * Given a layout json object, compiles all referenced extracted files from it
+ * and returns the updated object with the extracted content joined and inlined.
+ */ const joinExtractedFiles = async (layoutDirCtx, layoutJson)=>{
+    // Tracks any errors encountered during traversal. Mutated in place.
+    const errors = [];
+    // Tracks each new valid extracted file path seen (rebased to be relative to
+    // layout.json) in the layout json node. Mutated in place, and used
+    // to validate the uniqueness of an extracted path encountered.
+    const uniqueFilePaths = {};
+    (0, _object.mapValuesDeep)(layoutJson, (relpath, 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)(layoutJson, inlinObjPathStr)) return;
+        // Check if the extracted path found at the current field path is valid
+        const invalidFilePathError = (0, _helpers.validateExtractedFilePath)(relpath, _nodePath.default.resolve(layoutDirCtx.abspath, _helpers1.LAYOUT_JSON), uniqueFilePaths, objPathToFieldStr);
+        if (invalidFilePathError) {
+            errors.push(invalidFilePathError);
+            // Wipe the invalid file path in the node so the final layout json
+            // object ends up with only valid file paths, this way layout writer
+            // can see only valid file paths and use those when pulling.
+            (0, _lodash.set)(layoutJson, inlinObjPathStr, undefined);
+            (0, _lodash.set)(layoutJson, objPathToFieldStr, undefined);
+            return;
+        }
+        // By this point we have a valid extracted file path, so attempt to read the file.
+        const [content, readExtractedFileError] = (0, _helpers.readExtractedFileSync)(relpath, layoutDirCtx, key);
+        if (readExtractedFileError) {
+            errors.push(readExtractedFileError);
+            // If there's an error, replace the extracted file path with the original one, and set the
+            // inlined field path in layout object with empty content, so we know
+            // we do not need to try inlining again.
+            (0, _lodash.set)(layoutJson, objPathToFieldStr, relpath);
+            (0, _lodash.set)(layoutJson, inlinObjPathStr, undefined);
+            return;
+        }
+        // Inline the file content and remove the extracted file path.
+        (0, _lodash.set)(layoutJson, objPathToFieldStr, relpath);
+        (0, _lodash.set)(layoutJson, inlinObjPathStr, content);
+    });
+    return [
+        layoutJson,
+        errors
+    ];
+};

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

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});