@knocklabs/cli 1.0.0 → 1.0.2

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

@@ -0,0 +1,149 @@
+"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 readAllForCommandTarget () {
+        return readAllForCommandTarget;
+    },
+    get readAudienceDir () {
+        return readAudienceDir;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _core = require("@oclif/core");
+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");
+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 audience directory contexts, read each audience dir and
+ * return audience directory data.
+ */ const readAudienceDirs = async (audienceDirCtxs)=>{
+    const audiences = [];
+    const errors = [];
+    for (const audienceDirCtx of audienceDirCtxs){
+        // eslint-disable-next-line no-await-in-loop
+        const [audience, readErrors] = await readAudienceDir(audienceDirCtx);
+        if (readErrors.length > 0) {
+            const audienceJsonPath = _nodepath.default.resolve(audienceDirCtx.abspath, _processorisomorphic.AUDIENCE_JSON);
+            const e = new _error.SourceError((0, _error.formatErrors)(readErrors), audienceJsonPath);
+            errors.push(e);
+            continue;
+        }
+        audiences.push({
+            ...audienceDirCtx,
+            content: audience
+        });
+    }
+    return [
+        audiences,
+        errors
+    ];
+};
+const readAudienceDir = async (audienceDirCtx)=>{
+    const { abspath } = audienceDirCtx;
+    const dirExists = await _fsextra.pathExists(abspath);
+    if (!dirExists) throw new Error(`${abspath} does not exist`);
+    const audienceJsonPath = await (0, _helpers.lsAudienceJson)(abspath);
+    if (!audienceJsonPath) throw new Error(`${abspath} is not an audience directory`);
+    const result = await (0, _json.readJson)(audienceJsonPath);
+    if (!result[0]) return result;
+    let [audienceJson] = result;
+    audienceJson = (0, _objectisomorphic.omitDeep)(audienceJson, [
+        "__readonly"
+    ]);
+    return [
+        audienceJson,
+        []
+    ];
+};
+const readAllForCommandTarget = async (target)=>{
+    const { type: targetType, context: targetCtx } = target;
+    if (!targetCtx.exists) {
+        const subject = targetType === "audienceDir" ? "an audience directory at" : "audience directories in";
+        return _core.ux.error(`Cannot locate ${subject} \`${targetCtx.abspath}\``);
+    }
+    switch(targetType){
+        case "audienceDir":
+            {
+                return readAudienceDirs([
+                    targetCtx
+                ]);
+            }
+        case "audiencesIndexDir":
+            {
+                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 audienceDirCtx = {
+                        type: "audience",
+                        key: dirent.name,
+                        abspath,
+                        exists: await (0, _helpers.isAudienceDir)(abspath)
+                    };
+                    return audienceDirCtx;
+                });
+                const audienceDirCtxs = (await Promise.all(promises)).filter((audienceDirCtx)=>audienceDirCtx.exists);
+                return readAudienceDirs(audienceDirCtxs);
+            }
+        default:
+            throw new Error(`Invalid audience command target: ${target}`);
+    }
+};

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AudienceType", {
+    enumerable: true,
+    get: function() {
+        return AudienceType;
+    }
+});
+var AudienceType = /*#__PURE__*/ function(AudienceType) {
+    AudienceType["Static"] = "static";
+    AudienceType["Dynamic"] = "dynamic";
+    return AudienceType;
+}({});

package/dist/lib/marshal/audience/writer.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 pruneAudiencesIndexDir () {
+        return pruneAudiencesIndexDir;
+    },
+    get writeAudienceDirFromBundle () {
+        return writeAudienceDirFromBundle;
+    },
+    get writeAudienceDirFromData () {
+        return writeAudienceDirFromData;
+    },
+    get writeAudiencesIndexDir () {
+        return writeAudiencesIndexDir;
+    }
+});
+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 AUDIENCE_SCHEMA = "https://schemas.knock.app/cli/audience.json";
+const writeAudienceDirFromData = async (audienceDirCtx, remoteAudience, options)=>{
+    const { withSchema = false } = options || {};
+    // If the audience directory exists on the file system (i.e. previously
+    // pulled before), then read the audience file to use as a reference.
+    const [localAudience] = audienceDirCtx.exists ? await (0, _reader.readAudienceDir)(audienceDirCtx) : [];
+    const bundle = (0, _processorisomorphic.buildAudienceDirBundle)(remoteAudience, localAudience, withSchema ? AUDIENCE_SCHEMA : undefined);
+    return writeAudienceDirFromBundle(audienceDirCtx, bundle);
+};
+/*
+ * A lower level write function that takes a constructed audience dir bundle
+ * and writes it into an audience directory on a local file system.
+ *
+ * It does not make any assumptions about how the audience directory bundle was
+ * built; for example, it can be from parsing the audience data fetched from
+ * the Knock API, or built manually for scaffolding purposes.
+ */ const writeAudienceDirFromBundle = async (audienceDirCtx, audienceDirBundle)=>{
+    const backupDirPath = _nodepath.resolve(_const.sandboxDir, (0, _lodash.uniqueId)("backup"));
+    try {
+        if (audienceDirCtx.exists) {
+            await _fsextra.copy(audienceDirCtx.abspath, backupDirPath);
+            await _fsextra.emptyDir(audienceDirCtx.abspath);
+        }
+        const promises = Object.entries(audienceDirBundle).map(([relpath, fileContent])=>{
+            const filePath = _nodepath.resolve(audienceDirCtx.abspath, relpath);
+            return relpath === _processorisomorphic.AUDIENCE_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 (audienceDirCtx.exists) {
+            await _fsextra.emptyDir(audienceDirCtx.abspath);
+            await _fsextra.copy(backupDirPath, audienceDirCtx.abspath);
+        } else {
+            await _fsextra.remove(audienceDirCtx.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
+ * audience dirs found in fetched audiences. We want to preserve any audience
+ * dirs that are going to be updated with remote audiences, so extracted links
+ * can be respected.
+ */ const pruneAudiencesIndexDir = async (indexDirCtx, remoteAudiences)=>{
+    const audiencesByKey = Object.fromEntries(remoteAudiences.map((a)=>[
+            a.key.toLowerCase(),
+            a
+        ]));
+    const dirents = await _fsextra.readdir(indexDirCtx.abspath, {
+        withFileTypes: true
+    });
+    const promises = dirents.map(async (dirent)=>{
+        const direntPath = _nodepath.resolve(indexDirCtx.abspath, dirent.name);
+        const direntKey = dirent.name.toLowerCase();
+        if (await (0, _helpers.isAudienceDir)(direntPath) && audiencesByKey[direntKey]) {
+            return;
+        }
+        await _fsextra.remove(direntPath);
+    });
+    await Promise.all(promises);
+};
+const writeAudiencesIndexDir = async (indexDirCtx, remoteAudiences, options)=>{
+    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 pruneAudiencesIndexDir(indexDirCtx, remoteAudiences);
+        }
+        // Write given remote audiences into the given audiences directory path.
+        const writeAudienceDirPromises = remoteAudiences.map(async (audience)=>{
+            const audienceDirPath = _nodepath.resolve(indexDirCtx.abspath, audience.key);
+            const audienceDirCtx = {
+                type: "audience",
+                key: audience.key,
+                abspath: audienceDirPath,
+                exists: indexDirCtx.exists ? await (0, _helpers.isAudienceDir)(audienceDirPath) : false
+            };
+            return writeAudienceDirFromData(audienceDirCtx, audience, options);
+        });
+        await Promise.all(writeAudienceDirPromises);
+    } 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);
+        } 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/index.isomorphic.js

@@ -11,32 +11,36 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    get buildAudienceDirBundle () {
+        return _processorisomorphic.buildAudienceDirBundle;
+    },
     get buildEmailLayoutDirBundle () {
-        return _processorisomorphic.buildEmailLayoutDirBundle;
+        return _processorisomorphic1.buildEmailLayoutDirBundle;
     },
     get buildGuideDirBundle () {
-        return _processorisomorphic1.buildGuideDirBundle;
+        return _processorisomorphic2.buildGuideDirBundle;
     },
     get buildMessageTypeDirBundle () {
-        return _processorisomorphic2.buildMessageTypeDirBundle;
+        return _processorisomorphic3.buildMessageTypeDirBundle;
     },
     get buildPartialDirBundle () {
-        return _processorisomorphic3.buildPartialDirBundle;
+        return _processorisomorphic4.buildPartialDirBundle;
     },
     get buildReusableStepDirBundle () {
-        return _processorisomorphic4.buildReusableStepDirBundle;
+        return _processorisomorphic5.buildReusableStepDirBundle;
     },
     get buildTranslationDirBundle () {
-        return _processorisomorphic5.buildTranslationDirBundle;
+        return _processorisomorphic6.buildTranslationDirBundle;
     },
     get buildWorkflowDirBundle () {
-        return _processorisomorphic6.buildWorkflowDirBundle;
+        return _processorisomorphic7.buildWorkflowDirBundle;
     }
 });
-const _processorisomorphic = require("./email-layout/processor.isomorphic");
-const _processorisomorphic1 = require("./guide/processor.isomorphic");
-const _processorisomorphic2 = require("./message-type/processor.isomorphic");
-const _processorisomorphic3 = require("./partial/processor.isomorphic");
-const _processorisomorphic4 = require("./reusable-step/processor.isomorphic");
-const _processorisomorphic5 = require("./translation/processor.isomorphic");
-const _processorisomorphic6 = require("./workflow/processor.isomorphic");
+const _processorisomorphic = require("./audience/processor.isomorphic");
+const _processorisomorphic1 = require("./email-layout/processor.isomorphic");
+const _processorisomorphic2 = require("./guide/processor.isomorphic");
+const _processorisomorphic3 = require("./message-type/processor.isomorphic");
+const _processorisomorphic4 = require("./partial/processor.isomorphic");
+const _processorisomorphic5 = require("./reusable-step/processor.isomorphic");
+const _processorisomorphic6 = require("./translation/processor.isomorphic");
+const _processorisomorphic7 = require("./workflow/processor.isomorphic");

package/dist/lib/resources.js

@@ -17,6 +17,8 @@ _export(exports, {
     }
 });
 const ALL_RESOURCE_TYPES = [
+    // Audiences can be referenced by workflows, so push them early
+    "audience",
     // Partials first, as email layouts and workflows may reference them
     "partial",
     // Email layouts next, as workflows with email channel steps may reference them
@@ -28,6 +30,7 @@ const ALL_RESOURCE_TYPES = [
     "translation"
 ];
 const RESOURCE_SUBDIRS = {
+    audience: "audiences",
     email_layout: "layouts",
     partial: "partials",
     translation: "translations",

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

@@ -13,6 +13,7 @@ Object.defineProperty(exports, "load", {
     }
 });
 const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+const _audience = /*#__PURE__*/ _interop_require_wildcard(require("../marshal/audience"));
 const _emaillayout = /*#__PURE__*/ _interop_require_wildcard(require("../marshal/email-layout"));
 const _guide = /*#__PURE__*/ _interop_require_wildcard(require("../marshal/guide"));
 const _messagetype = /*#__PURE__*/ _interop_require_wildcard(require("../marshal/message-type"));
@@ -71,31 +72,22 @@ const buildResourceDirContext = (type, currDir)=>{
 const evaluateRecursively = async (ctx, currDir)=>{
     // 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) {
+        if (await _audience.isAudienceDir(currDir)) {
+            ctx.resourceDir = buildResourceDirContext("audience", currDir);
+        } else if (await _workflow.isWorkflowDir(currDir)) {
             ctx.resourceDir = buildResourceDirContext("workflow", currDir);
-        }
-        const isGuideDir = await _guide.isGuideDir(currDir);
-        if (isGuideDir) {
+        } else if (await _guide.isGuideDir(currDir)) {
             ctx.resourceDir = buildResourceDirContext("guide", currDir);
-        }
-        const isEmailLayoutDir = await _emaillayout.isEmailLayoutDir(currDir);
-        if (isEmailLayoutDir) {
+        } else if (await _emaillayout.isEmailLayoutDir(currDir)) {
             ctx.resourceDir = buildResourceDirContext("email_layout", currDir);
-        }
-        const isPartialDir = await _partial.isPartialDir(currDir);
-        if (isPartialDir) {
+        } else if (await _partial.isPartialDir(currDir)) {
             ctx.resourceDir = buildResourceDirContext("partial", currDir);
-        }
-        const isMessageTypeDir = await _messagetype.isMessageTypeDir(currDir);
-        if (isMessageTypeDir) {
+        } else if (await _messagetype.isMessageTypeDir(currDir)) {
             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) {
+        } else if (_translation.isTranslationDir(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.
             ctx.resourceDir = buildResourceDirContext("translation", currDir);
         }
     }

package/dist/lib/urls.js

@@ -24,6 +24,9 @@ _export(exports, {
     get authSuccessUrl () {
         return authSuccessUrl;
     },
+    get viewAudienceUrl () {
+        return viewAudienceUrl;
+    },
     get viewGuideUrl () {
         return viewGuideUrl;
     },
@@ -50,3 +53,4 @@ const viewGuideUrl = (dashboardUrl, accountSlug, envOrBranchSlug, guideKey)=>`${
 const viewLayoutUrl = (dashboardUrl, accountSlug, envOrBranchSlug, layoutKey)=>`${dashboardUrl}/${accountSlug}/${envOrBranchSlug.toLowerCase()}/layouts/${layoutKey}`;
 const viewMessageTypeUrl = (dashboardUrl, accountSlug, envOrBranchSlug, messageTypeKey)=>`${dashboardUrl}/${accountSlug}/${envOrBranchSlug.toLowerCase()}/message-types/${messageTypeKey}`;
 const viewPartialUrl = (dashboardUrl, accountSlug, envOrBranchSlug, partialKey)=>`${dashboardUrl}/${accountSlug}/${envOrBranchSlug.toLowerCase()}/partials/${partialKey}`;
+const viewAudienceUrl = (dashboardUrl, accountSlug, envOrBranchSlug, audienceKey)=>`${dashboardUrl}/${accountSlug}/${envOrBranchSlug.toLowerCase()}/audiences/${audienceKey}`;