@knocklabs/cli 0.1.18 → 0.1.20

package/dist/lib/api-v1.js

@@ -239,6 +239,100 @@ class ApiV1 {
             params
         });
     }
+    // By resources: Partials
+    async listPartials({ flags }) {
+        const params = (0, _objectisomorphic.prune)({
+            environment: flags.environment,
+            hide_uncommitted_changes: flags["hide-uncommitted-changes"],
+            annotate: flags.annotate,
+            ...(0, _page.toPageParams)(flags)
+        });
+        return this.get("/partials", {
+            params
+        });
+    }
+    async getPartial({ args, flags }) {
+        const params = (0, _objectisomorphic.prune)({
+            environment: flags.environment,
+            annotate: flags.annotate,
+            hide_uncommitted_changes: flags["hide-uncommitted-changes"]
+        });
+        return this.get(`/partials/${args.partialKey}`, {
+            params
+        });
+    }
+    async upsertPartial({ flags }, partial) {
+        const params = (0, _objectisomorphic.prune)({
+            environment: flags.environment,
+            annotate: flags.annotate,
+            commit: flags.commit,
+            commit_message: flags["commit-message"]
+        });
+        const data = {
+            partial
+        };
+        return this.put(`/partials/${partial.key}`, data, {
+            params
+        });
+    }
+    async validatePartial({ flags }, partial) {
+        const params = (0, _objectisomorphic.prune)({
+            environment: flags.environment
+        });
+        const data = {
+            partial
+        };
+        return this.put(`/partials/${partial.key}/validate`, data, {
+            params
+        });
+    }
+    // By resources: Message types
+    async listMessageTypes({ flags }) {
+        const params = (0, _objectisomorphic.prune)({
+            environment: flags.environment,
+            hide_uncommitted_changes: flags["hide-uncommitted-changes"],
+            annotate: flags.annotate,
+            ...(0, _page.toPageParams)(flags)
+        });
+        return this.get("/message_types", {
+            params
+        });
+    }
+    async getMessageType({ args, flags }) {
+        const params = (0, _objectisomorphic.prune)({
+            environment: flags.environment,
+            annotate: flags.annotate,
+            hide_uncommitted_changes: flags["hide-uncommitted-changes"]
+        });
+        return this.get(`/message_types/${args.messageTypeKey}`, {
+            params
+        });
+    }
+    async upsertMessageType({ flags }, messageType) {
+        const params = (0, _objectisomorphic.prune)({
+            environment: flags.environment,
+            annotate: flags.annotate,
+            commit: flags.commit,
+            commit_message: flags["commit-message"]
+        });
+        const data = {
+            message_type: messageType
+        };
+        return this.put(`/message_types/${messageType.key}`, data, {
+            params
+        });
+    }
+    async validateMessageType({ flags }, messageType) {
+        const params = (0, _objectisomorphic.prune)({
+            environment: flags.environment
+        });
+        const data = {
+            message_type: messageType
+        };
+        return this.put(`/message_types/${messageType.key}/validate`, data, {
+            params
+        });
+    }
     // By methods:
     async get(subpath, config) {
         return this.client.get(`/${API_VERSION}` + subpath, config);

package/dist/lib/base-command.js

@@ -88,10 +88,7 @@ class BaseCommand extends _core.Command {
         this.runContext = await _runcontext.load(this.id);
     }
     constructor(...args){
-        super(...args);
-        _define_property(this, "props", void 0);
-        _define_property(this, "apiV1", void 0);
-        _define_property(this, "runContext", void 0);
+        super(...args), _define_property(this, "props", void 0), _define_property(this, "apiV1", void 0), _define_property(this, "runContext", void 0);
     }
 }
 // Base flags are inherited by any command that extends BaseCommand.

package/dist/lib/helpers/const.js

@@ -68,10 +68,10 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-var KnockEnv;
-(function(KnockEnv) {
+var KnockEnv = /*#__PURE__*/ function(KnockEnv) {
     KnockEnv["Development"] = "development";
     KnockEnv["Production"] = "production";
-})(KnockEnv || (KnockEnv = {}));
+    return KnockEnv;
+}({});
 const isTestEnv = process.env.NODE_ENV === "test";
 const sandboxDir = _nodepath.resolve(_fsextra.realpathSync(_nodeos.default.tmpdir()), ".knock");

package/dist/lib/helpers/error.js

@@ -63,16 +63,14 @@ class JsonSyntaxError extends CustomError {
 }
 class JsonDataError extends CustomError {
     constructor(message, objPath){
-        super(message);
-        // For example: `foo.bar[2].baz`
+        super(message), // For example: `foo.bar[2].baz`
         _define_property(this, "objPath", void 0);
         this.objPath = objPath;
     }
 }
 class LiquidParseError extends CustomError {
     constructor(message, context){
-        super(message);
-        // Shows the erroneous liquid content with line numbers, should be taken
+        super(message), // Shows the erroneous liquid content with line numbers, should be taken
         // directly from a LiquidError.
         _define_property(this, "context", void 0);
         this.context = context;
@@ -80,8 +78,7 @@ class LiquidParseError extends CustomError {
 }
 class SourceError extends CustomError {
     constructor(message, source, tag){
-        super(tag ? `${tag}: ${message}` : message);
-        // Arbitrary string to describe the identifying source of the error message.
+        super(tag ? `${tag}: ${message}` : message), // Arbitrary string to describe the identifying source of the error message.
         _define_property(this, "source", void 0);
         this.source = source;
     }

package/dist/lib/helpers/liquid.js

@@ -19,8 +19,6 @@ const disabled = {
         throw new Error(`"${token.name}" tag is not supported in Knock`);
     }
 };
-// TODO(KNO-6058) - Enable render tag for partials
-engine.registerTag("render", disabled);
 engine.registerTag("include", disabled);
 function validateLiquidSyntax(input) {
     try {

package/dist/lib/helpers/page.js

@@ -58,11 +58,11 @@ const pageFlags = {
 const toPageParams = (flags)=>{
     return (0, _lodash.pick)(flags, Object.keys(pageFlags));
 };
-var PageAction;
-(function(PageAction) {
+var PageAction = /*#__PURE__*/ function(PageAction) {
     PageAction["Previous"] = "p";
     PageAction["Next"] = "n";
-})(PageAction || (PageAction = {}));
+    return PageAction;
+}({});
 /*
  * Format a prompt text to show available page actions.
  * e.g. [p: preview, n: next]

package/dist/lib/marshal/guide/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./processor.isomorphic"), exports);
+_export_star(require("./types"), exports);
+function _export_star(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/guide/processor.isomorphic.js

@@ -0,0 +1,85 @@
+/*
+ * IMPORTANT:
+ *
+ * This file is suffixed with `.isomorphic` because the code in this file is
+ * meant to run not just in a nodejs environment but also in a browser. For this
+ * reason there are some restrictions for which nodejs imports are allowed in
+ * this module. See `.eslintrc.json` for more details.
+ */ "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, {
+    GUIDE_JSON: function() {
+        return GUIDE_JSON;
+    },
+    buildGuideDirBundle: function() {
+        return buildGuideDirBundle;
+    }
+});
+const _lodash = require("lodash");
+const _objectisomorphic = require("../../helpers/object.isomorphic");
+const _constisomorphic = require("../shared/const.isomorphic");
+const _helpersisomorphic = require("../shared/helpers.isomorphic");
+const GUIDE_JSON = "guide.json";
+const compileExtractionSettings = (guide)=>{
+    const extractableFields = (0, _lodash.get)(guide, [
+        "__annotation",
+        "extractable_fields"
+    ], {});
+    const map = new Map();
+    for (const [key] of Object.entries(guide)){
+        // 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;
+};
+const buildGuideDirBundle = (remoteGuide, localGuide = {})=>{
+    const bundle = {};
+    const mutRemoteGuide = (0, _lodash.cloneDeep)(remoteGuide);
+    // A map of extraction settings of every field in the guide.
+    const compiledExtractionSettings = compileExtractionSettings(mutRemoteGuide);
+    // 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 field path does not exist, then we don't extract.
+        if (!(0, _lodash.has)(mutRemoteGuide, objPathParts)) continue;
+        // If the field at this path is extracted in the local guide, then always
+        // extract; otherwise extract based on the field settings default.
+        const objPathStr = _objectisomorphic.ObjPath.stringify(objPathParts);
+        const extractedFilePath = (0, _lodash.get)(localGuide, `${objPathStr}${_constisomorphic.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)(mutRemoteGuide, objPathParts);
+        const fileName = objPathParts.pop();
+        // If we have an extracted file path from the local guide, we use that;
+        // otherwise 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)(mutRemoteGuide, `${objPathStr}${_constisomorphic.FILEPATH_MARKER}`, relpath);
+        (0, _lodash.unset)(mutRemoteGuide, objPathStr);
+    }
+    // At this point the bundle contains all extractable files, so we finally add
+    // the guide JSON relative path + the file content.
+    return (0, _lodash.set)(bundle, [
+        GUIDE_JSON
+    ], (0, _helpersisomorphic.prepareResourceJson)(mutRemoteGuide));
+};

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

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

package/dist/lib/marshal/index.isomorphic.js

@@ -14,21 +14,25 @@ _export(exports, {
     buildEmailLayoutDirBundle: function() {
         return _processorisomorphic.buildEmailLayoutDirBundle;
     },
+    buildGuideDirBundle: function() {
+        return _processorisomorphic1.buildGuideDirBundle;
+    },
     buildMessageTypeDirBundle: function() {
-        return _processorisomorphic1.buildMessageTypeDirBundle;
+        return _processorisomorphic2.buildMessageTypeDirBundle;
     },
     buildPartialDirBundle: function() {
-        return _processorisomorphic2.buildPartialDirBundle;
+        return _processorisomorphic3.buildPartialDirBundle;
     },
     buildTranslationDirBundle: function() {
-        return _processorisomorphic3.buildTranslationDirBundle;
+        return _processorisomorphic4.buildTranslationDirBundle;
     },
     buildWorkflowDirBundle: function() {
-        return _processorisomorphic4.buildWorkflowDirBundle;
+        return _processorisomorphic5.buildWorkflowDirBundle;
     }
 });
 const _processorisomorphic = require("./email-layout/processor.isomorphic");
-const _processorisomorphic1 = require("./message-type/processor.isomorphic");
-const _processorisomorphic2 = require("./partial/processor.isomorphic");
-const _processorisomorphic3 = require("./translation/processor.isomorphic");
-const _processorisomorphic4 = require("./workflow/processor.isomorphic");
+const _processorisomorphic1 = require("./guide/processor.isomorphic");
+const _processorisomorphic2 = require("./message-type/processor.isomorphic");
+const _processorisomorphic3 = require("./partial/processor.isomorphic");
+const _processorisomorphic4 = require("./translation/processor.isomorphic");
+const _processorisomorphic5 = require("./workflow/processor.isomorphic");

package/dist/lib/marshal/message-type/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, {
+    ensureValidCommandTarget: function() {
+        return ensureValidCommandTarget;
+    },
+    isMessageTypeDir: function() {
+        return isMessageTypeDir;
+    },
+    lsMessageTypeJson: function() {
+        return lsMessageTypeJson;
+    },
+    messageTypeJsonPath: function() {
+        return messageTypeJsonPath;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+const _core = require("@oclif/core");
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _processorisomorphic = require("./processor.isomorphic");
+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 messageTypeJsonPath = (messageTypeDirCtx)=>_nodepath.resolve(messageTypeDirCtx.abspath, _processorisomorphic.MESSAGE_TYPE_JSON);
+const lsMessageTypeJson = async (dirPath)=>{
+    const messageTypeJsonPath = _nodepath.resolve(dirPath, _processorisomorphic.MESSAGE_TYPE_JSON);
+    const exists = await _fsextra.pathExists(messageTypeJsonPath);
+    return exists ? messageTypeJsonPath : undefined;
+};
+const isMessageTypeDir = async (dirPath)=>Boolean(await lsMessageTypeJson(dirPath));
+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 !== "message_type") {
+        return _core.ux.error(`Cannot run ${commandId} inside a ${resourceDirCtx.type} directory`);
+    }
+    // Cannot accept both message type key arg and --all flag.
+    if (flags.all && args.messageTypeKey) {
+        return _core.ux.error(`messageTypeKey arg \`${args.messageTypeKey}\` cannot also be provided when using --all`);
+    }
+    // --all flag is given, which means no message type key arg.
+    if (flags.all) {
+        // If --all flag used inside a message type directory, then require a message
+        // types dir path.
+        if (resourceDirCtx && !flags["message-types-dir"]) {
+            return _core.ux.error("Missing required flag message-types-dir");
+        }
+        // Targeting all message type dirs in the message types index dir.
+        // TODO: Default to the knock project config first if present before cwd.
+        const defaultToCwd = {
+            abspath: runCwd,
+            exists: true
+        };
+        const indexDirCtx = flags["message-types-dir"] || defaultToCwd;
+        return {
+            type: "messageTypesIndexDir",
+            context: indexDirCtx
+        };
+    }
+    // Message type key arg is given, which means no --all flag.
+    if (args.messageTypeKey) {
+        if (resourceDirCtx && resourceDirCtx.key !== args.messageTypeKey) {
+            return _core.ux.error(`Cannot run ${commandId} \`${args.messageTypeKey}\` inside another message type directory:\n${resourceDirCtx.key}`);
+        }
+        const targetDirPath = resourceDirCtx ? resourceDirCtx.abspath : _nodepath.resolve(runCwd, args.messageTypeKey);
+        const messageTypeDirCtx = {
+            type: "message_type",
+            key: args.messageTypeKey,
+            abspath: targetDirPath,
+            exists: await isMessageTypeDir(targetDirPath)
+        };
+        return {
+            type: "messageTypeDir",
+            context: messageTypeDirCtx
+        };
+    }
+    // From this point on, we have neither a message type key arg nor --all flag.
+    // If running inside a message type directory, then use that message type
+    // directory.
+    if (resourceDirCtx) {
+        return {
+            type: "messageTypeDir",
+            context: resourceDirCtx
+        };
+    }
+    return _core.ux.error("Missing 1 required arg:\nmessageTypeKey");
+};

package/dist/lib/marshal/message-type/index.js

@@ -2,8 +2,11 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+_export_star(require("./helpers"), exports);
 _export_star(require("./processor.isomorphic"), exports);
+_export_star(require("./reader"), exports);
 _export_star(require("./types"), exports);
+_export_star(require("./writer"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/dist/lib/marshal/message-type/reader.js

@@ -0,0 +1,198 @@
+"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: function() {
+        return readAllForCommandTarget;
+    },
+    readMessageTypeDir: function() {
+        return readMessageTypeDir;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _core = require("@oclif/core");
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _lodash = require("lodash");
+const _error = require("../../helpers/error");
+const _json = require("../../helpers/json");
+const _objectisomorphic = require("../../helpers/object.isomorphic");
+const _helpers = require("../shared/helpers");
+const _constisomorphic = require("../shared/const.isomorphic");
+const _helpers1 = require("./helpers");
+const _processorisomorphic = require("./processor.isomorphic");
+function _interop_require_default(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 _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;
+}
+/*
+ * For the given list of message type directory contexts, read each message type dir and
+ * return message type directory data.
+ */ const readMessageTypeDirs = async (messageTypeDirCtxs, opts = {})=>{
+    const messageTypes = [];
+    const errors = [];
+    for (const messageTypeDirCtx of messageTypeDirCtxs){
+        // eslint-disable-next-line no-await-in-loop
+        const [messageType, readErrors] = await readMessageTypeDir(messageTypeDirCtx, opts);
+        if (readErrors.length > 0) {
+            const messageTypeJsonPath = _nodepath.default.resolve(messageTypeDirCtx.abspath, _processorisomorphic.MESSAGE_TYPE_JSON);
+            const e = new _error.SourceError((0, _error.formatErrors)(readErrors), messageTypeJsonPath);
+            errors.push(e);
+            continue;
+        }
+        messageTypes.push({
+            ...messageTypeDirCtx,
+            content: messageType
+        });
+    }
+    return [
+        messageTypes,
+        errors
+    ];
+};
+const readMessageTypeDir = async (messageTypeDirCtx, opts = {})=>{
+    const { abspath } = messageTypeDirCtx;
+    const { withExtractedFiles = false, withReadonlyField = false } = opts;
+    const dirExists = await _fsextra.pathExists(abspath);
+    if (!dirExists) throw new Error(`${abspath} does not exist`);
+    const messageTypeJsonPath = await (0, _helpers1.lsMessageTypeJson)(abspath);
+    if (!messageTypeJsonPath) throw new Error(`${abspath} is not a message type directory`);
+    const result = await (0, _json.readJson)(messageTypeJsonPath);
+    if (!result[0]) return result;
+    let [messageTypeJson] = result;
+    messageTypeJson = withReadonlyField ? messageTypeJson : (0, _objectisomorphic.omitDeep)(messageTypeJson, [
+        "__readonly"
+    ]);
+    return withExtractedFiles ? joinExtractedFiles(messageTypeDirCtx, messageTypeJson) : [
+        messageTypeJson,
+        []
+    ];
+};
+const joinExtractedFiles = async (messageTypeDirCtx, messageTypeJson)=>{
+    // Tracks any errors encountered during traversal. Mutated in place.
+    const errors = [];
+    // Tracks each new valid extracted file path seen (rebased to be relative to
+    // message_type.json) in the message type json node. Mutated in place, and used
+    // to validate the uniqueness of an extracted path encountered.
+    const uniqueFilePaths = {};
+    (0, _objectisomorphic.mapValuesDeep)(messageTypeJson, (relpath, key, parts)=>{
+        // If not marked with the @suffix, there's nothing to do.
+        if (!_constisomorphic.FILEPATH_MARKED_RE.test(key)) return;
+        const objPathToFieldStr = _objectisomorphic.ObjPath.stringify(parts);
+        const inlinObjPathStr = objPathToFieldStr.replace(_constisomorphic.FILEPATH_MARKED_RE, "");
+        // If there is inlined content present already, then nothing more to do.
+        if ((0, _lodash.hasIn)(messageTypeJson, inlinObjPathStr)) return;
+        // Check if the extracted path found at the current field path is valid
+        const invalidFilePathError = (0, _helpers.validateExtractedFilePath)(relpath, _nodepath.default.resolve(messageTypeDirCtx.abspath, _processorisomorphic.MESSAGE_TYPE_JSON), uniqueFilePaths, objPathToFieldStr);
+        if (invalidFilePathError) {
+            errors.push(invalidFilePathError);
+            // Wipe the invalid file path in the node so the final message type json
+            // object ends up with only valid file paths, this way message type writer
+            // can see only valid file paths and use those when pulling.
+            (0, _lodash.set)(messageTypeJson, inlinObjPathStr, undefined);
+            (0, _lodash.set)(messageTypeJson, 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, messageTypeDirCtx, 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 message type object with empty content, so we know
+            // we do not need to try inlining again.
+            (0, _lodash.set)(messageTypeJson, objPathToFieldStr, relpath);
+            (0, _lodash.set)(messageTypeJson, inlinObjPathStr, undefined);
+            return;
+        }
+        // Inline the file content and remove the extracted file path.
+        (0, _lodash.set)(messageTypeJson, objPathToFieldStr, relpath);
+        (0, _lodash.set)(messageTypeJson, inlinObjPathStr, content);
+    });
+    return [
+        messageTypeJson,
+        errors
+    ];
+};
+const readAllForCommandTarget = async (target, opts = {})=>{
+    const { type: targetType, context: targetCtx } = target;
+    if (!targetCtx.exists) {
+        const subject = targetType === "messageTypeDir" ? "a message type directory at" : "message type directories in";
+        return _core.ux.error(`Cannot locate ${subject} \`${targetCtx.abspath}\``);
+    }
+    switch(targetType){
+        case "messageTypeDir":
+            {
+                return readMessageTypeDirs([
+                    targetCtx
+                ], opts);
+            }
+        case "messageTypesIndexDir":
+            {
+                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 messageTypeDirCtx = {
+                        type: "message_type",
+                        key: dirent.name,
+                        abspath,
+                        exists: await (0, _helpers1.isMessageTypeDir)(abspath)
+                    };
+                    return messageTypeDirCtx;
+                });
+                const messageTypeDirCtxs = (await Promise.all(promises)).filter((messageTypeDirCtx)=>messageTypeDirCtx.exists);
+                return readMessageTypeDirs(messageTypeDirCtxs, opts);
+            }
+        default:
+            throw new Error(`Invalid message type command target: ${target}`);
+    }
+};