@knocklabs/cli 0.1.0-rc.4 → 0.1.3

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

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "readTranslationFilesForCommandTarget", {
+Object.defineProperty(exports, "readAllForCommandTarget", {
     enumerable: true,
-    get: ()=>readTranslationFilesForCommandTarget
+    get: ()=>readAllForCommandTarget
 });
 const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
 const _core = require("@oclif/core");
@@ -56,6 +56,9 @@ function _interopRequireWildcard(obj, nodeInterop) {
  * translation file data.
  *
  * Note, it assumes they are valid file paths to translation files.
+ *
+ * TODO: Refactor to take translation file contexts instead of raw file paths,
+ * to keep things consistent with the workflow reader module.
  */ const readTranslationFiles = async (filePaths)=>{
     const translations = [];
     const errors = [];
@@ -69,27 +72,27 @@ function _interopRequireWildcard(obj, nodeInterop) {
         if (readJsonErrors.length > 0) {
             const e = new _error.SourceError((0, _error.formatErrors)(readJsonErrors), abspath);
             errors.push(e);
+            continue;
         }
-        if (content) {
-            translations.push({
-                ref: translationRef,
-                localeCode,
-                namespace,
-                abspath,
-                exists: true,
-                content: JSON.stringify(content)
-            });
-        }
+        translations.push({
+            ref: translationRef,
+            localeCode,
+            namespace,
+            abspath,
+            exists: true,
+            content: JSON.stringify(content)
+        });
     }
     return [
         translations,
         errors
     ];
 };
-const readTranslationFilesForCommandTarget = async (target)=>{
+const readAllForCommandTarget = async (target)=>{
     const { type: targetType , context: targetCtx  } = target;
     if (!targetCtx.exists) {
-        return _core.CliUx.ux.error(`Cannot locate translation file(s) at \`${targetCtx.abspath}\``);
+        const subject = targetType === "translationFile" ? "a translation file at" : "translation files in";
+        return _core.ux.error(`Cannot locate ${subject} \`${targetCtx.abspath}\``);
     }
     switch(targetType){
         case "translationFile":

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

@@ -1,3 +1,4 @@
+// Translation payload data from the API.
 "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true

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

@@ -2,9 +2,15 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "writeTranslationsIndexDir", {
-    enumerable: true,
-    get: ()=>writeTranslationsIndexDir
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    writeTranslationFile: ()=>writeTranslationFile,
+    writeTranslationFiles: ()=>writeTranslationFiles
 });
 const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
 const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
@@ -51,32 +57,36 @@ function _interopRequireWildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-const writeTranslationsIndexDir = async (indexDirCtx, translations)=>{
+const writeTranslationFile = async (translationFileCtx, translation)=>_fsExtra.outputJson(translationFileCtx.abspath, JSON.parse(translation.content), {
+        spaces: _json.DOUBLE_SPACES
+    });
+const writeTranslationFiles = async (targetDirCtx, translations)=>{
     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 _fsExtra.emptyDir(indexDirCtx.abspath);
+        if (targetDirCtx.exists) {
+            await _fsExtra.copy(targetDirCtx.abspath, backupDirPath);
+            await _fsExtra.emptyDir(targetDirCtx.abspath);
         }
         // Write given remote translations into the given translations directory path.
         const writeTranslationDirPromises = translations.map(async (translation)=>{
-            const translationDirPath = _nodePath.resolve(indexDirCtx.abspath, translation.locale_code);
-            const translationFileCtx = await (0, _helpers.buildTranslationFileCtx)(translationDirPath, translation.locale_code, translation.namespace);
-            return _fsExtra.outputJson(translationFileCtx.abspath, JSON.parse(translation.content), {
-                spaces: _json.DOUBLE_SPACES
-            });
+            // If TranslationDirContext, then that is the locale directory we want
+            // to write translation files in; otherwise for translations index
+            // directory, we want to nest translation files under each locale dir.
+            const localeDirPath = "key" in targetDirCtx ? targetDirCtx.abspath : _nodePath.resolve(targetDirCtx.abspath, translation.locale_code);
+            const translationFileCtx = await (0, _helpers.buildTranslationFileCtx)(localeDirPath, translation.locale_code, translation.namespace);
+            return writeTranslationFile(translationFileCtx, translation);
         });
         await Promise.all(writeTranslationDirPromises);
     } catch (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);
+        if (targetDirCtx.exists) {
+            await _fsExtra.emptyDir(targetDirCtx.abspath);
+            await _fsExtra.copy(backupDirPath, targetDirCtx.abspath);
         } else {
-            await _fsExtra.remove(indexDirCtx.abspath);
+            await _fsExtra.remove(targetDirCtx.abspath);
         }
         throw error;
     } finally{

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

@@ -11,6 +11,7 @@ function _export(target, all) {
 _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,
@@ -18,9 +19,11 @@ _export(exports, {
     isWorkflowDir: ()=>isWorkflowDir,
     formatCategories: ()=>formatCategories,
     formatStepSummary: ()=>formatStepSummary,
-    formatStatus: ()=>formatStatus
+    formatStatus: ()=>formatStatus,
+    ensureValidCommandTarget: ()=>ensureValidCommandTarget
 });
 const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
+const _core = require("@oclif/core");
 const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
 const _lodash = require("lodash");
 const _string = require("../../helpers/string");
@@ -66,6 +69,7 @@ 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)=>{
@@ -77,7 +81,7 @@ const validateWorkflowKey = (input)=>{
     return undefined;
 };
 const lsWorkflowJson = async (dirPath)=>{
-    const workflowJsonPath = _nodePath.join(dirPath, WORKFLOW_JSON);
+    const workflowJsonPath = _nodePath.resolve(dirPath, WORKFLOW_JSON);
     const exists = await _fsExtra.pathExists(workflowJsonPath);
     return exists ? workflowJsonPath : undefined;
 };
@@ -149,3 +153,61 @@ const formatStepSummary = (step)=>{
 const formatStatus = (workflow)=>{
     return workflow.active ? "active" : "inactive";
 };
+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 !== "workflow") {
+        return _core.ux.error(`Cannot run ${commandId} inside a ${resourceDirCtx.type} directory`);
+    }
+    // Cannot accept both workflow key arg and --all flag.
+    if (flags.all && args.workflowKey) {
+        return _core.ux.error(`workflowKey arg \`${args.workflowKey}\` cannot also be provided when using --all`);
+    }
+    // --all flag is given, which means no workflow key arg.
+    if (flags.all) {
+        // If --all flag used inside a workflow directory, then require a workflows
+        // dir path.
+        if (resourceDirCtx && !flags["workflows-dir"]) {
+            return _core.ux.error("Missing required flag workflows-dir");
+        }
+        // Targeting all workflow dirs in the workflows index dir.
+        // TODO: Default to the knock project config first if present before cwd.
+        const defaultToCwd = {
+            abspath: runCwd,
+            exists: true
+        };
+        const indexDirCtx = flags["workflows-dir"] || defaultToCwd;
+        return {
+            type: "workflowsIndexDir",
+            context: indexDirCtx
+        };
+    }
+    // Workflow key arg is given, which means no --all flag.
+    if (args.workflowKey) {
+        if (resourceDirCtx && resourceDirCtx.key !== args.workflowKey) {
+            return _core.ux.error(`Cannot run ${commandId} \`${args.workflowKey}\` inside another workflow directory:\n${resourceDirCtx.key}`);
+        }
+        const targetDirPath = resourceDirCtx ? resourceDirCtx.abspath : _nodePath.resolve(runCwd, args.workflowKey);
+        const workflowDirCtx = {
+            type: "workflow",
+            key: args.workflowKey,
+            abspath: targetDirPath,
+            exists: await isWorkflowDir(targetDirPath)
+        };
+        return {
+            type: "workflowDir",
+            context: workflowDirCtx
+        };
+    }
+    // From this point on, we have neither a workflow key arg nor --all flag.
+    // If running inside a workflow directory, then use that workflow directory.
+    if (resourceDirCtx) {
+        return {
+            type: "workflowDir",
+            context: resourceDirCtx
+        };
+    }
+    return _core.ux.error("Missing 1 required arg:\nworkflowKey");
+};

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

@@ -10,10 +10,12 @@ function _export(target, all) {
 }
 _export(exports, {
     readWorkflowDir: ()=>readWorkflowDir,
+    readAllForCommandTarget: ()=>readAllForCommandTarget,
     checkIfValidExtractedFilePathFormat: ()=>checkIfValidExtractedFilePathFormat,
     readExtractedFileSync: ()=>readExtractedFileSync
 });
 const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
+const _core = require("@oclif/core");
 const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
 const _lodash = require("lodash");
 const _error = require("../../helpers/error");
@@ -247,3 +249,63 @@ const readWorkflowDir = async (workflowDirCtx, opts = {})=>{
         []
     ];
 };
+/*
+ * For the given list of workflow directory contexts, read each workflow dir and
+ * return workflow directory data.
+ */ const readWorkflowDirs = async (workflowDirCtxs, opts = {})=>{
+    const workflows = [];
+    const errors = [];
+    for (const workflowDirCtx of workflowDirCtxs){
+        // 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 e = new _error.SourceError((0, _error.formatErrors)(readErrors), workflowJsonPath);
+            errors.push(e);
+            continue;
+        }
+        workflows.push({
+            ...workflowDirCtx,
+            content: workflow
+        });
+    }
+    return [
+        workflows,
+        errors
+    ];
+};
+const readAllForCommandTarget = async (target, opts = {})=>{
+    const { type: targetType , context: targetCtx  } = target;
+    if (!targetCtx.exists) {
+        const subject = targetType === "workflowDir" ? "a workflow directory at" : "workflow directories in";
+        return _core.ux.error(`Cannot locate ${subject} \`${targetCtx.abspath}\``);
+    }
+    switch(targetType){
+        case "workflowDir":
+            {
+                return readWorkflowDirs([
+                    targetCtx
+                ], opts);
+            }
+        case "workflowsIndexDir":
+            {
+                const dirents = await _fsExtra.readdir(targetCtx.abspath, {
+                    withFileTypes: true
+                });
+                const promises = dirents.map(async (dirent)=>{
+                    const abspath = _nodePath.resolve(targetCtx.abspath, dirent.name);
+                    const workflowDirCtx = {
+                        type: "workflow",
+                        key: dirent.name,
+                        abspath,
+                        exists: await (0, _helpers.isWorkflowDir)(abspath)
+                    };
+                    return workflowDirCtx;
+                });
+                const workflowDirCtxs = (await Promise.all(promises)).filter((workflowDirCtx)=>workflowDirCtx.exists);
+                return readWorkflowDirs(workflowDirCtxs, opts);
+            }
+        default:
+            throw new Error(`Invalid workflow command target: ${target}`);
+    }
+};

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

@@ -11,7 +11,7 @@ const ensureResourceDirForTarget = (resourceDirCtx, target)=>{
     // If the target resource is a different type than the current resource dir
     // type, error out.
     if (resourceDirCtx.type !== target.type) {
-        return _core.CliUx.ux.error(`Cannot run ${target.commandId} inside a ${resourceDirCtx.type} directory`);
+        return _core.ux.error(`Cannot run ${target.commandId} inside a ${resourceDirCtx.type} directory`);
     }
     // If the resource key was not provided with the command, then infer from the
     // current resource directory context.
@@ -23,5 +23,5 @@ const ensureResourceDirForTarget = (resourceDirCtx, target)=>{
     if (target.key === resourceDirCtx.key) {
         return resourceDirCtx;
     }
-    return _core.CliUx.ux.error(`Cannot run ${target.commandId} \`${target.key}\` inside another ${resourceDirCtx.type} directory:\n${resourceDirCtx.key}`);
+    return _core.ux.error(`Cannot run ${target.commandId} \`${target.key}\` inside another ${resourceDirCtx.type} directory:\n${resourceDirCtx.key}`);
 };