@knocklabs/cli 1.1.2 → 1.2.2

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

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get SCHEMA_FILE_SCHEMA () {
+        return SCHEMA_FILE_SCHEMA;
+    },
+    get isSchemaItemType () {
+        return isSchemaItemType;
+    },
+    get resolveSchemasDir () {
+        return resolveSchemasDir;
+    },
+    get schemaFileContext () {
+        return schemaFileContext;
+    },
+    get schemaFilePath () {
+        return schemaFilePath;
+    },
+    get schemaTargetFromData () {
+        return schemaTargetFromData;
+    },
+    get validateSchemaCollection () {
+        return validateSchemaCollection;
+    },
+    get validateSchemaItemType () {
+        return validateSchemaItemType;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _types = require("./types");
+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;
+}
+const SCHEMA_FILE_SCHEMA = "https://schemas.knock.app/cli/schema.json";
+const isSchemaItemType = (value)=>_types.SCHEMA_ITEM_TYPES.includes(value);
+const validateSchemaItemType = (value)=>{
+    if (!isSchemaItemType(value)) {
+        throw new Error(`Invalid item type \`${value}\`. Must be one of: ${_types.SCHEMA_ITEM_TYPES.join(", ")}`);
+    }
+    return value;
+};
+const validateSchemaCollection = (collection)=>{
+    if (!collection || collection.includes("/") || collection.includes("\\") || collection === "." || collection === "..") {
+        throw new Error(`Invalid object collection \`${collection}\``);
+    }
+    return collection;
+};
+const resolveSchemasDir = async (projectConfig, basePath)=>{
+    const schemasDirPath = projectConfig ? _nodepath.default.resolve(_nodepath.default.isAbsolute(projectConfig.knockDir) ? projectConfig.knockDir : _nodepath.default.resolve(basePath, projectConfig.knockDir), "schemas") : _nodepath.default.resolve(basePath, "schemas");
+    const exists = await _fsextra.pathExists(schemasDirPath);
+    if (exists && !(await _fsextra.lstat(schemasDirPath)).isDirectory()) {
+        throw new Error(`${schemasDirPath} is not a directory`);
+    }
+    return {
+        abspath: schemasDirPath,
+        exists
+    };
+};
+const schemaFilePath = (schemasDirPath, itemType, collection)=>{
+    if (itemType === "object") {
+        return _nodepath.default.resolve(schemasDirPath, "objects", `${validateSchemaCollection(collection !== null && collection !== void 0 ? collection : "")}.json`);
+    }
+    return _nodepath.default.resolve(schemasDirPath, `${itemType}.json`);
+};
+const schemaFileContext = async (schemasDirPath, itemType, collection)=>{
+    const abspath = schemaFilePath(schemasDirPath, itemType, collection);
+    const exists = await _fsextra.pathExists(abspath);
+    if (exists && !(await _fsextra.lstat(abspath)).isFile()) {
+        throw new Error(`${abspath} is not a file`);
+    }
+    return {
+        itemType,
+        collection,
+        abspath,
+        exists
+    };
+};
+const schemaTargetFromData = (schema)=>{
+    const itemType = validateSchemaItemType(schema.item_type);
+    if (itemType === "object") {
+        var _schema_item_id;
+        return {
+            itemType,
+            collection: validateSchemaCollection((_schema_item_id = schema.item_id) !== null && _schema_item_id !== void 0 ? _schema_item_id : "")
+        };
+    }
+    return {
+        itemType
+    };
+};

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./helpers"), 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)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

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

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get readAllSchemaFiles () {
+        return readAllSchemaFiles;
+    },
+    get readSchemaFile () {
+        return readSchemaFile;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _error = require("../../helpers/error");
+const _json = require("../../helpers/json");
+const _objectisomorphic = require("../../helpers/object.isomorphic");
+const _helpers = require("./helpers");
+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;
+}
+const readSchemaFile = async (schemaFileCtx)=>{
+    if (!schemaFileCtx.exists) {
+        throw new Error(`Cannot locate schema file at \`${schemaFileCtx.abspath}\``);
+    }
+    const [schemaJson, readErrors] = await (0, _json.readJson)(schemaFileCtx.abspath);
+    if (!schemaJson) {
+        return [
+            undefined,
+            [
+                new _error.SourceError((0, _error.formatErrors)(readErrors), schemaFileCtx.abspath)
+            ]
+        ];
+    }
+    const schema = (0, _objectisomorphic.omitDeep)(schemaJson, [
+        "$schema",
+        "__readonly"
+    ]);
+    return [
+        schema,
+        []
+    ];
+};
+const readAllSchemaFiles = async (schemasDirPath)=>{
+    if (!await _fsextra.pathExists(schemasDirPath)) {
+        throw new Error(`Cannot locate schema files in \`${schemasDirPath}\``);
+    }
+    const schemas = [];
+    const errors = [];
+    for (const itemType of [
+        "user",
+        "tenant"
+    ]){
+        // eslint-disable-next-line no-await-in-loop
+        const ctx = await (0, _helpers.schemaFileContext)(schemasDirPath, itemType);
+        if (!ctx.exists) continue;
+        // eslint-disable-next-line no-await-in-loop
+        const [content, readErrors] = await readSchemaFile(ctx);
+        if (readErrors.length > 0) {
+            errors.push(...readErrors);
+            continue;
+        }
+        schemas.push({
+            ...ctx,
+            content: content
+        });
+    }
+    const objectsDirPath = _nodepath.default.resolve(schemasDirPath, "objects");
+    if (await _fsextra.pathExists(objectsDirPath)) {
+        const dirents = await _fsextra.readdir(objectsDirPath, {
+            withFileTypes: true
+        });
+        for (const dirent of dirents){
+            if (!dirent.isFile() || !dirent.name.endsWith(".json")) continue;
+            const collection = _nodepath.default.basename(dirent.name, ".json");
+            // An invalid filename (e.g. `..json`) fails collection validation;
+            // collect it like any other read error instead of aborting the run.
+            let ctx;
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                ctx = await (0, _helpers.schemaFileContext)(schemasDirPath, "object", collection);
+            } catch (error) {
+                errors.push(new _error.SourceError(error.message, _nodepath.default.resolve(objectsDirPath, dirent.name), "ReadError"));
+                continue;
+            }
+            // eslint-disable-next-line no-await-in-loop
+            const [content, readErrors] = await readSchemaFile(ctx);
+            if (readErrors.length > 0) {
+                errors.push(...readErrors);
+                continue;
+            }
+            schemas.push({
+                ...ctx,
+                content: content
+            });
+        }
+    }
+    const validated = [];
+    for (const schema of schemas){
+        try {
+            const itemType = (0, _helpers.validateSchemaItemType)(schema.content.item_type);
+            // The file path determines where a schema is pushed, so a file that
+            // declares a different item_type is ambiguous. Error instead of silently
+            // reinterpreting it.
+            if (itemType !== schema.itemType) {
+                throw new Error(`Schema file declares item_type \`${itemType}\` but its file path implies \`${schema.itemType}\``);
+            }
+            // Same for an object schema whose declared item_id disagrees with its
+            // objects/<collection>.json path.
+            if (itemType === "object" && schema.content.item_id && schema.content.item_id !== schema.collection) {
+                throw new Error(`Schema file declares item_id \`${schema.content.item_id}\` but its file path implies \`${schema.collection}\``);
+            }
+            validated.push({
+                ...schema,
+                content: {
+                    ...schema.content,
+                    item_type: itemType
+                }
+            });
+        } catch (error) {
+            errors.push(new _error.SourceError(error.message, schema.abspath, "ReadError"));
+        }
+    }
+    return [
+        validated,
+        errors
+    ];
+};

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SCHEMA_ITEM_TYPES", {
+    enumerable: true,
+    get: function() {
+        return SCHEMA_ITEM_TYPES;
+    }
+});
+const SCHEMA_ITEM_TYPES = [
+    "user",
+    "tenant",
+    "object"
+];

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

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get schemaJsonForWrite () {
+        return schemaJsonForWrite;
+    },
+    get writeSchemaFileFromData () {
+        return writeSchemaFileFromData;
+    },
+    get writeSchemasIndexDir () {
+        return writeSchemasIndexDir;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(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");
+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;
+}
+const schemaJsonForWrite = (schema)=>{
+    var _schema_item_id, _schema_item_id1;
+    return {
+        $schema: _helpers.SCHEMA_FILE_SCHEMA,
+        item_type: schema.item_type,
+        item_id: (_schema_item_id = schema.item_id) !== null && _schema_item_id !== void 0 ? _schema_item_id : null,
+        properties: schema.properties,
+        __readonly: {
+            item_type: schema.item_type,
+            item_id: (_schema_item_id1 = schema.item_id) !== null && _schema_item_id1 !== void 0 ? _schema_item_id1 : null
+        }
+    };
+};
+const writeSchemaFileFromData = async (schemaFileCtx, schema)=>{
+    await _fsextra.outputJson(schemaFileCtx.abspath, schemaJsonForWrite(schema), {
+        spaces: _json.DOUBLE_SPACES
+    });
+};
+/*
+ * Prunes schema files that are no longer present in the remote set, so a later
+ * `schema push --all` cannot push stale schemas back into the environment.
+ * Only removes the file shapes push reads (user.json, tenant.json, and
+ * objects/<collection>.json); anything else in the directory is left alone.
+ */ const pruneSchemasIndexDir = async (schemasDirPath, remoteSchemas)=>{
+    const expectedPaths = new Set(remoteSchemas.map((schema)=>{
+        const { itemType, collection } = (0, _helpers.schemaTargetFromData)(schema);
+        return (0, _helpers.schemaFilePath)(schemasDirPath, itemType, collection);
+    }));
+    const candidatePaths = [
+        _nodepath.default.resolve(schemasDirPath, "user.json"),
+        _nodepath.default.resolve(schemasDirPath, "tenant.json")
+    ];
+    const objectsDirPath = _nodepath.default.resolve(schemasDirPath, "objects");
+    if (await _fsextra.pathExists(objectsDirPath)) {
+        const dirents = await _fsextra.readdir(objectsDirPath, {
+            withFileTypes: true
+        });
+        for (const dirent of dirents){
+            if (dirent.isFile() && dirent.name.endsWith(".json")) {
+                candidatePaths.push(_nodepath.default.resolve(objectsDirPath, dirent.name));
+            }
+        }
+    }
+    await Promise.all(candidatePaths.filter((abspath)=>!expectedPaths.has(abspath)).map((abspath)=>_fsextra.remove(abspath)));
+};
+const writeSchemasIndexDir = async (schemasDirPath, schemas)=>{
+    const dirExists = await _fsextra.pathExists(schemasDirPath);
+    const backupDirPath = _nodepath.default.resolve(_const.sandboxDir, (0, _lodash.uniqueId)("backup"));
+    let backedUp = false;
+    try {
+        // If the schemas directory already exists, back it up in the temp sandbox
+        // before pruning stale files, so a failed write can restore it.
+        if (dirExists) {
+            await _fsextra.copy(schemasDirPath, backupDirPath);
+            backedUp = true;
+            await pruneSchemasIndexDir(schemasDirPath, schemas);
+        }
+        for (const schema of schemas){
+            const { itemType, collection } = (0, _helpers.schemaTargetFromData)(schema);
+            // eslint-disable-next-line no-await-in-loop
+            const ctx = await (0, _helpers.schemaFileContext)(schemasDirPath, itemType, collection);
+            // eslint-disable-next-line no-await-in-loop
+            await writeSchemaFileFromData(ctx, schema);
+        }
+    } catch (error) {
+        // In case of any error, wipe the schemas directory that is likely in a bad
+        // state then restore the backup, but only when the backup completed. If
+        // the backup copy itself failed, nothing has touched the original tree, so
+        // leave it alone.
+        if (dirExists && backedUp) {
+            await _fsextra.emptyDir(schemasDirPath);
+            await _fsextra.copy(backupDirPath, schemasDirPath);
+        } else if (!dirExists) {
+            await _fsextra.remove(schemasDirPath);
+        }
+        throw error;
+    } finally{
+        // Always clean up the backup directory in the temp sandbox.
+        await _fsextra.remove(backupDirPath);
+    }
+};

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get formatMappingStatus () {
+        return formatMappingStatus;
+    },
+    get formatPreprocessScript () {
+        return formatPreprocessScript;
+    },
+    get formatSettingValue () {
+        return formatSettingValue;
+    }
+});
+const formatSettingValue = (value)=>{
+    if (value === undefined || value === null || value === "") return "-";
+    if (typeof value === "boolean") return value ? "Yes" : "No";
+    return String(value);
+};
+const formatPreprocessScript = (settings)=>settings.preprocess_script ? settings.preprocess_script.language : "-";
+const formatMappingStatus = (mapping)=>mapping.active ? "Active" : "Inactive";

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

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

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

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

@@ -157,7 +157,7 @@ const scaffoldInAppFeedChannelStep = (refSuffix, channels)=>{
     const scaffoldedStep = {
         ref: stepRef,
         type: _types.StepType.Channel,
-        channel_key: firstChannel ? firstChannel.key : "<IN-APP-FEED CHANNEL KEY>",
+        channel_key: firstChannel ? firstChannel.key : "<IN_APP_FEED CHANNEL KEY>",
         template: {
             action_url: "{{ vars.app_url }}",
             ["markdown_body" + _constisomorphic.FILEPATH_MARKER]: templateFilePath
@@ -239,7 +239,7 @@ const STEP_TAGS = [
     "batch",
     "fetch",
     "email",
-    "in-app-feed",
+    "in_app_feed",
     "sms",
     "push",
     "chat"
@@ -249,7 +249,7 @@ const StepTagChoices = {
     batch: "Batch step",
     fetch: "HTTP Fetch step",
     email: "Email channel step",
-    "in-app-feed": "In-app feed channel step",
+    in_app_feed: "In-app feed channel step",
     sms: "SMS channel step",
     push: "Push channel step",
     chat: "Chat channel step"
@@ -261,13 +261,16 @@ const stepScaffoldFuncs = {
     fetch: scaffoldHttpFetchStep,
     // Channel steps
     email: scaffoldEmailChannelStep,
-    "in-app-feed": scaffoldInAppFeedChannelStep,
+    in_app_feed: scaffoldInAppFeedChannelStep,
     sms: scaffoldSmsChannelStep,
     push: scaffoldPushChannelStep,
     chat: scaffoldChatChannelStep
 };
+// Accept "in-app-feed" for backward compatibility, but normalize to the snake
+// case one as the canonical tag.
+const normalizeStepTag = (tag)=>tag === "in-app-feed" ? "in_app_feed" : tag;
 const parseStepsInput = (input, availableStepTypes)=>{
-    const tags = input.split(",").filter((x)=>x);
+    const tags = input.split(",").filter((x)=>x).map((tag)=>normalizeStepTag(tag));
     const invalidTags = tags.filter((tag)=>!availableStepTypes.includes(tag));
     if (invalidTags.length > 0) {
         return [
@@ -286,7 +289,7 @@ const getAvailableStepTypes = (channelTypes)=>{
         switch(stepTag){
             case "email":
                 return channelTypes.includes("email");
-            case "in-app-feed":
+            case "in_app_feed":
                 return channelTypes.includes("in_app_feed");
             case "sms":
                 return channelTypes.includes("sms");
@@ -310,12 +313,11 @@ const scaffoldWorkflowDirBundle = (attrs, channelsByType)=>{
         const stepCount = ++stepCountByTag[tag];
         switch(tag){
             case "email":
+            case "in_app_feed":
             case "sms":
             case "push":
             case "chat":
                 return stepScaffoldFuncs[tag](stepCount, (0, _lodash.get)(channelsByType, tag, []));
-            case "in-app-feed":
-                return stepScaffoldFuncs[tag](stepCount, (0, _lodash.get)(channelsByType, "in_app_feed", []));
             default:
                 return stepScaffoldFuncs[tag](stepCount);
         }
@@ -348,6 +350,7 @@ function swapChannelReferences(step, channelsByType) {
                 ...step,
                 channel_key: (_channelsByType_email_ = channelsByType.email[0]) === null || _channelsByType_email_ === void 0 ? void 0 : _channelsByType_email_.key
             };
+        case "in_app_feed":
         case "in-app-feed":
         case "knock-in-app-feed":
         case "knock-feed":

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

@@ -24,6 +24,9 @@ _export(exports, {
     get formatStepSummary () {
         return formatStepSummary;
     },
+    get formatTags () {
+        return formatTags;
+    },
     get generateWorkflowTypes () {
         return generateWorkflowTypes;
     },
@@ -106,13 +109,14 @@ const lsWorkflowJson = async (dirPath)=>{
     return exists ? workflowJsonPath : undefined;
 };
 const isWorkflowDir = async (dirPath)=>Boolean(await lsWorkflowJson(dirPath));
-const formatCategories = (workflow, opts = {})=>{
-    const { categories } = workflow;
+const formatCategories = (workflow, opts = {})=>formatStringList(workflow.categories, opts);
+const formatTags = (workflow, opts = {})=>formatStringList(workflow.tags, opts);
+const formatStringList = (items, opts = {})=>{
     const { truncateAfter: limit, emptyDisplay = "" } = opts;
-    if (!categories) return emptyDisplay;
-    const count = categories.length;
-    if (!limit || limit >= count) return categories.join(", ");
-    return (0, _lodash.take)(categories, limit).join(", ") + ` (+ ${count - limit} more)`;
+    if (!items) return emptyDisplay;
+    const count = items.length;
+    if (!limit || limit >= count) return items.join(", ");
+    return (0, _lodash.take)(items, limit).join(", ") + ` (+ ${count - limit} more)`;
 };
 /*
  * Returns a formatted string of workflow steps.