@knocklabs/cli 1.0.0-rc.1 → 1.0.2

package/dist/commands/push.js

@@ -16,12 +16,13 @@ const _const = require("../lib/helpers/const");
 const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../lib/helpers/flag"));
 const _projectconfig = require("../lib/helpers/project-config");
 const _resources = require("../lib/resources");
-const _push = /*#__PURE__*/ _interop_require_default(require("./guide/push"));
-const _push1 = /*#__PURE__*/ _interop_require_default(require("./layout/push"));
-const _push2 = /*#__PURE__*/ _interop_require_default(require("./message-type/push"));
-const _push3 = /*#__PURE__*/ _interop_require_default(require("./partial/push"));
-const _push4 = /*#__PURE__*/ _interop_require_default(require("./translation/push"));
-const _push5 = /*#__PURE__*/ _interop_require_default(require("./workflow/push"));
+const _push = /*#__PURE__*/ _interop_require_default(require("./audience/push"));
+const _push1 = /*#__PURE__*/ _interop_require_default(require("./guide/push"));
+const _push2 = /*#__PURE__*/ _interop_require_default(require("./layout/push"));
+const _push3 = /*#__PURE__*/ _interop_require_default(require("./message-type/push"));
+const _push4 = /*#__PURE__*/ _interop_require_default(require("./partial/push"));
+const _push5 = /*#__PURE__*/ _interop_require_default(require("./translation/push"));
+const _push6 = /*#__PURE__*/ _interop_require_default(require("./workflow/push"));
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -155,38 +156,44 @@ const runResourcePushCommand = async (resourceType, targetDirCtx, args)=>{
         return;
     }
     switch(resourceType){
+        case "audience":
+            return _push.default.run([
+                ...args,
+                "--audiences-dir",
+                subdirPath
+            ]);
         case "email_layout":
-            return _push1.default.run([
+            return _push2.default.run([
                 ...args,
                 "--layouts-dir",
                 subdirPath
             ]);
         case "partial":
-            return _push3.default.run([
+            return _push4.default.run([
                 ...args,
                 "--partials-dir",
                 subdirPath
             ]);
         case "translation":
-            return _push4.default.run([
+            return _push5.default.run([
                 ...args,
                 "--translations-dir",
                 subdirPath
             ]);
         case "workflow":
-            return _push5.default.run([
+            return _push6.default.run([
                 ...args,
                 "--workflows-dir",
                 subdirPath
             ]);
         case "message_type":
-            return _push2.default.run([
+            return _push3.default.run([
                 ...args,
                 "--message-types-dir",
                 subdirPath
             ]);
         case "guide":
-            return _push.default.run([
+            return _push1.default.run([
                 ...args,
                 "--guides-dir",
                 subdirPath

package/dist/commands/workflow/open.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return WorkflowOpen;
+    }
+});
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _browser = require("../../lib/helpers/browser");
+const _error = require("../../lib/helpers/error");
+const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
+const _request = require("../../lib/helpers/request");
+const _urls = require("../../lib/urls");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+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;
+}
+class WorkflowOpen extends _basecommand.default {
+    async run() {
+        const whoamiResp = await this.apiV1.whoami();
+        if (!(0, _request.isSuccessResp)(whoamiResp)) {
+            const message = (0, _request.formatErrorRespMessage)(whoamiResp);
+            _core.ux.error(new _error.ApiError(message));
+        }
+        const { account_slug } = whoamiResp.data;
+        const { workflowKey } = this.props.args;
+        const { environment, branch } = this.props.flags;
+        const envOrBranch = branch !== null && branch !== void 0 ? branch : environment;
+        const url = (0, _urls.viewWorkflowUrl)(this.sessionContext.dashboardOrigin, account_slug, envOrBranch, workflowKey);
+        this.log(`‣ Opening workflow \`${workflowKey}\` in the Knock dashboard...`);
+        this.log(`  ${url}`);
+        await _browser.browser.openUrl(url);
+    }
+}
+_define_property(WorkflowOpen, "summary", "Open a workflow in the Knock dashboard.");
+_define_property(WorkflowOpen, "flags", {
+    environment: _core.Flags.string({
+        default: "development",
+        summary: "The environment to use."
+    }),
+    branch: _flag.branch
+});
+_define_property(WorkflowOpen, "args", {
+    workflowKey: _core.Args.string({
+        required: true
+    })
+});

package/dist/lib/helpers/git.js

@@ -2,9 +2,17 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "isFileIgnoredByGit", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get getCurrentGitBranch () {
+        return getCurrentGitBranch;
+    },
+    get isFileIgnoredByGit () {
         return isFileIgnoredByGit;
     }
 });
@@ -23,3 +31,14 @@ const isFileIgnoredByGit = async (currDir, filePath)=>{
         return false;
     }
 };
+const getCurrentGitBranch = ()=>{
+    try {
+        const branch = (0, _nodechild_process.execSync)("git rev-parse --abbrev-ref HEAD", {
+            stdio: "pipe",
+            encoding: "utf-8"
+        }).trim();
+        return branch;
+    } catch  {
+        return undefined;
+    }
+};

package/dist/lib/helpers/project-config.js

@@ -130,6 +130,7 @@ const findAndReadProjectConfig = async ()=>{
     return readProjectConfig(configPath);
 };
 const ResourceDirectoriesByType = {
+    audience: "audiences",
     workflow: "workflows",
     guide: "guides",
     partial: "partials",

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

@@ -0,0 +1,38 @@
+"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 generateAudienceDir () {
+        return generateAudienceDir;
+    },
+    get scaffoldAudienceDirBundle () {
+        return scaffoldAudienceDirBundle;
+    }
+});
+const _processorisomorphic = require("./processor.isomorphic");
+const _writer = require("./writer");
+/*
+ * Scaffolds a new audience directory bundle with default content.
+ */ const scaffoldAudienceDirBundle = (attrs)=>{
+    const audienceJson = {
+        name: attrs.name,
+        type: attrs.type
+    };
+    if (attrs.description) {
+        audienceJson.description = attrs.description;
+    }
+    return {
+        [_processorisomorphic.AUDIENCE_JSON]: audienceJson
+    };
+};
+const generateAudienceDir = async (audienceDirCtx, attrs)=>{
+    const bundle = scaffoldAudienceDirBundle(attrs);
+    return (0, _writer.writeAudienceDirFromBundle)(audienceDirCtx, bundle);
+};

package/dist/lib/marshal/audience/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 audienceJsonPath () {
+        return audienceJsonPath;
+    },
+    get ensureValidCommandTarget () {
+        return ensureValidCommandTarget;
+    },
+    get isAudienceDir () {
+        return isAudienceDir;
+    },
+    get lsAudienceJson () {
+        return lsAudienceJson;
+    },
+    get validateAudienceKey () {
+        return validateAudienceKey;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+const _core = require("@oclif/core");
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _projectconfig = require("../../helpers/project-config");
+const _string = require("../../helpers/string");
+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 audienceJsonPath = (audienceDirCtx)=>_nodepath.resolve(audienceDirCtx.abspath, _processorisomorphic.AUDIENCE_JSON);
+const lsAudienceJson = async (dirPath)=>{
+    const audienceJsonPath = _nodepath.resolve(dirPath, _processorisomorphic.AUDIENCE_JSON);
+    const exists = await _fsextra.pathExists(audienceJsonPath);
+    return exists ? audienceJsonPath : undefined;
+};
+const isAudienceDir = async (dirPath)=>Boolean(await lsAudienceJson(dirPath));
+const validateAudienceKey = (input)=>{
+    if (!(0, _string.checkSlugifiedFormat)(input, {
+        onlyLowerCase: true
+    })) {
+        return "must include only lowercase alphanumeric, dash, or underscore characters";
+    }
+    return undefined;
+};
+const ensureValidCommandTarget = async (props, runContext, projectConfig)=>{
+    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 !== "audience") {
+        return _core.ux.error(`Cannot run ${commandId} inside a ${resourceDirCtx.type} directory`);
+    }
+    // Cannot accept both audience key arg and --all flag.
+    if (flags.all && args.audienceKey) {
+        return _core.ux.error(`audienceKey arg \`${args.audienceKey}\` cannot also be provided when using --all`);
+    }
+    // Default to knock project config first if present, otherwise cwd.
+    const audiencesIndexDirCtx = await (0, _projectconfig.resolveResourceDir)(projectConfig, "audience", runCwd);
+    // --all flag is given, which means no audience key arg.
+    if (flags.all) {
+        // If --all flag used inside an audience directory, then require an audiences
+        // dir path.
+        if (resourceDirCtx && !flags["audiences-dir"]) {
+            return _core.ux.error("Missing required flag audiences-dir");
+        }
+        return {
+            type: "audiencesIndexDir",
+            context: flags["audiences-dir"] || audiencesIndexDirCtx
+        };
+    }
+    // Audience key arg is given, which means no --all flag.
+    if (args.audienceKey) {
+        if (resourceDirCtx && resourceDirCtx.key !== args.audienceKey) {
+            return _core.ux.error(`Cannot run ${commandId} \`${args.audienceKey}\` inside another audience directory:\n${resourceDirCtx.key}`);
+        }
+        const targetDirPath = resourceDirCtx ? resourceDirCtx.abspath : _nodepath.resolve(audiencesIndexDirCtx.abspath, args.audienceKey);
+        const audienceDirCtx = {
+            type: "audience",
+            key: args.audienceKey,
+            abspath: targetDirPath,
+            exists: await isAudienceDir(targetDirPath)
+        };
+        return {
+            type: "audienceDir",
+            context: audienceDirCtx
+        };
+    }
+    // From this point on, we have neither an audience key arg nor --all flag.
+    // If running inside an audience directory, then use that audience directory.
+    if (resourceDirCtx) {
+        return {
+            type: "audienceDir",
+            context: resourceDirCtx
+        };
+    }
+    return _core.ux.error("Missing 1 required arg:\naudienceKey");
+};

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

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

package/dist/lib/marshal/audience/processor.isomorphic.js

@@ -0,0 +1,25 @@
+"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 AUDIENCE_JSON () {
+        return AUDIENCE_JSON;
+    },
+    get buildAudienceDirBundle () {
+        return buildAudienceDirBundle;
+    }
+});
+const _helpersisomorphic = require("../shared/helpers.isomorphic");
+const AUDIENCE_JSON = "audience.json";
+const buildAudienceDirBundle = (remoteAudience, _localAudience, $schema)=>{
+    return {
+        [AUDIENCE_JSON]: (0, _helpersisomorphic.prepareResourceJson)(remoteAudience, $schema)
+    };
+};

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;
+}({});