@knocklabs/cli 1.0.0 → 1.0.2

package/dist/commands/audience/open.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return AudienceOpen;
+    }
+});
+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 AudienceOpen 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 { audienceKey } = this.props.args;
+        const { environment, branch } = this.props.flags;
+        const envOrBranch = branch !== null && branch !== void 0 ? branch : environment;
+        const url = (0, _urls.viewAudienceUrl)(this.sessionContext.dashboardOrigin, account_slug, envOrBranch, audienceKey);
+        this.log(`‣ Opening audience \`${audienceKey}\` in the Knock dashboard...`);
+        this.log(`  ${url}`);
+        await _browser.browser.openUrl(url);
+    }
+}
+_define_property(AudienceOpen, "summary", "Open an audience in the Knock dashboard.");
+_define_property(AudienceOpen, "flags", {
+    environment: _core.Flags.string({
+        default: "development",
+        summary: "The environment to use."
+    }),
+    branch: _flag.branch
+});
+_define_property(AudienceOpen, "args", {
+    audienceKey: _core.Args.string({
+        required: true
+    })
+});

package/dist/commands/audience/pull.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return AudiencePull;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _command = require("../../lib/helpers/command");
+const _error = require("../../lib/helpers/error");
+const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
+const _projectconfig = require("../../lib/helpers/project-config");
+const _ux = require("../../lib/helpers/ux");
+const _audience = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/audience"));
+const _runcontext = require("../../lib/run-context");
+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 AudiencePull extends _basecommand.default {
+    async run() {
+        const { args, flags } = this.props;
+        if (flags.all && args.audienceKey) {
+            return this.error(`audienceKey arg \`${args.audienceKey}\` cannot also be provided when using --all`);
+        }
+        return flags.all ? this.pullAllAudiences() : this.pullOneAudience();
+    }
+    // Pull one audience
+    async pullOneAudience() {
+        const { flags } = this.props;
+        const dirContext = await this.getAudienceDirContext();
+        if (dirContext.exists) {
+            this.log(`‣ Found \`${dirContext.key}\` at ${dirContext.abspath}`);
+        } else {
+            const prompt = `Create a new audience directory \`${dirContext.key}\` at ${dirContext.abspath}?`;
+            const input = flags.force || await (0, _ux.promptToConfirm)(prompt);
+            if (!input) return;
+        }
+        _ux.spinner.start("‣ Loading");
+        try {
+            const audience = await this.apiV1.mgmtClient.audiences.retrieve(dirContext.key, {
+                environment: flags.environment,
+                branch: flags.branch,
+                annotate: true,
+                hide_uncommitted_changes: flags["hide-uncommitted-changes"]
+            });
+            _ux.spinner.stop();
+            // The SDK doesn't include annotation types, but the API returns them when annotate=true
+            await _audience.writeAudienceDirFromData(dirContext, audience, {
+                withSchema: true
+            });
+            const action = dirContext.exists ? "updated" : "created";
+            const scope = (0, _command.formatCommandScope)(flags);
+            this.log(`‣ Successfully ${action} \`${dirContext.key}\` at ${dirContext.abspath} using ${scope}`);
+        } catch (error) {
+            _ux.spinner.stop();
+            _core.ux.error(new _error.ApiError(error.message));
+        }
+    }
+    // Pull all audiences
+    async pullAllAudiences() {
+        const { flags } = this.props;
+        const audiencesIndexDirCtx = await (0, _projectconfig.resolveResourceDir)(this.projectConfig, "audience", this.runContext.cwd);
+        const targetDirCtx = flags["audiences-dir"] || audiencesIndexDirCtx;
+        const prompt = targetDirCtx.exists ? `Pull latest audiences into ${targetDirCtx.abspath}?\n  This will overwrite the contents of this directory.` : `Create a new audiences directory at ${targetDirCtx.abspath}?`;
+        const input = flags.force || await (0, _ux.promptToConfirm)(prompt);
+        if (!input) return;
+        _ux.spinner.start(`‣ Loading`);
+        try {
+            const audiences = await this.listAllAudiences();
+            // The SDK doesn't include annotation types, but the API returns them when annotate=true
+            await _audience.writeAudiencesIndexDir(targetDirCtx, audiences, {
+                withSchema: true
+            });
+            _ux.spinner.stop();
+            const action = targetDirCtx.exists ? "updated" : "created";
+            const scope = (0, _command.formatCommandScope)(flags);
+            this.log(`‣ Successfully ${action} the audiences directory at ${targetDirCtx.abspath} using ${scope}`);
+        } catch (error) {
+            _ux.spinner.stop();
+            _core.ux.error(new _error.ApiError(error.message));
+        }
+    }
+    async listAllAudiences() {
+        const { flags } = this.props;
+        const audiences = [];
+        for await (const audience of this.apiV1.mgmtClient.audiences.list({
+            environment: flags.environment,
+            branch: flags.branch,
+            annotate: true,
+            hide_uncommitted_changes: flags["hide-uncommitted-changes"]
+        })){
+            // The SDK doesn't include annotation types, but the API returns them when annotate=true
+            audiences.push(audience);
+        }
+        return audiences;
+    }
+    async getAudienceDirContext() {
+        const { audienceKey } = this.props.args;
+        const { resourceDir, cwd: runCwd } = this.runContext;
+        // Inside an existing resource dir, use it if valid for the target audience.
+        if (resourceDir) {
+            const target = {
+                commandId: _basecommand.default.id,
+                type: "audience",
+                key: audienceKey
+            };
+            return (0, _runcontext.ensureResourceDirForTarget)(resourceDir, target);
+        }
+        const audiencesIndexDirCtx = await (0, _projectconfig.resolveResourceDir)(this.projectConfig, "audience", runCwd);
+        // Not inside any existing audience directory, which means either create a
+        // new audience directory in the cwd, or update it if there is one already.
+        if (audienceKey) {
+            const dirPath = _nodepath.resolve(audiencesIndexDirCtx.abspath, audienceKey);
+            const exists = await _audience.isAudienceDir(dirPath);
+            return {
+                type: "audience",
+                key: audienceKey,
+                abspath: dirPath,
+                exists
+            };
+        }
+        // Not in any audience directory, nor an audience key arg was given so error.
+        return this.error("Missing 1 required arg:\naudienceKey");
+    }
+}
+_define_property(AudiencePull, "summary", "Pull one or more audiences from an environment into a local file system.");
+_define_property(AudiencePull, "flags", {
+    environment: _core.Flags.string({
+        default: "development",
+        summary: "The environment to use."
+    }),
+    branch: _flag.branch,
+    all: _core.Flags.boolean({
+        summary: "Whether to pull all audiences from the specified environment."
+    }),
+    "audiences-dir": _flag.dirPath({
+        summary: "The target directory path to pull all audiences into.",
+        dependsOn: [
+            "all"
+        ]
+    }),
+    "hide-uncommitted-changes": _core.Flags.boolean({
+        summary: "Hide any uncommitted changes."
+    }),
+    force: _core.Flags.boolean({
+        summary: "Remove the confirmation prompt."
+    })
+});
+_define_property(AudiencePull, "args", {
+    audienceKey: _core.Args.string({
+        required: false
+    })
+});

package/dist/commands/audience/push.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return AudiencePush;
+    }
+});
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _command = require("../../lib/helpers/command");
+const _const = require("../../lib/helpers/const");
+const _error = require("../../lib/helpers/error");
+const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
+const _string = require("../../lib/helpers/string");
+const _ux = require("../../lib/helpers/ux");
+const _audience = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/audience"));
+const _validate = /*#__PURE__*/ _interop_require_default(require("./validate"));
+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 AudiencePush extends _basecommand.default {
+    async run() {
+        const { flags } = this.props;
+        // 1. First read all audience directories found for the given command.
+        const target = await _audience.ensureValidCommandTarget(this.props, this.runContext, this.projectConfig);
+        const [audiences, readErrors] = await _audience.readAllForCommandTarget(target);
+        if (readErrors.length > 0) {
+            this.error((0, _error.formatErrors)(readErrors, {
+                prependBy: "\n\n"
+            }));
+        }
+        if (audiences.length === 0) {
+            this.error(`No audience directories found in ${target.context.abspath}`);
+        }
+        // 2. Then validate them all ahead of pushing them.
+        _ux.spinner.start(`‣ Validating`);
+        const apiErrors = await _validate.default.validateAll(this.apiV1, this.props, audiences);
+        if (apiErrors.length > 0) {
+            this.error((0, _error.formatErrors)(apiErrors, {
+                prependBy: "\n\n"
+            }));
+        }
+        _ux.spinner.stop();
+        // 3. Finally push up each audience, abort on the first error.
+        _ux.spinner.start(`‣ Pushing`);
+        for (const audience of audiences){
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                const resp = await this.apiV1.mgmtClient.audiences.upsert(audience.key, {
+                    environment: flags.environment,
+                    branch: flags.branch,
+                    annotate: true,
+                    commit: flags.commit,
+                    commit_message: flags["commit-message"],
+                    audience: audience.content
+                });
+                // Update the audience directory with the successfully pushed audience
+                // payload from the server.
+                // The SDK doesn't include annotation types, but the API returns them when annotate=true
+                // eslint-disable-next-line no-await-in-loop
+                await _audience.writeAudienceDirFromData(audience, resp.audience, {
+                    withSchema: true
+                });
+            } catch (error) {
+                const sourceError = new _error.SourceError(error.message, _audience.audienceJsonPath(audience), "ApiError");
+                this.error((0, _error.formatError)(sourceError));
+            }
+        }
+        _ux.spinner.stop();
+        // 4. Display a success message.
+        const audienceKeys = audiences.map((a)=>a.key);
+        const actioned = flags.commit ? "pushed and committed" : "pushed";
+        const scope = (0, _command.formatCommandScope)(flags);
+        this.log(`‣ Successfully ${actioned} ${audiences.length} audience(s) to ${scope}:\n` + (0, _string.indentString)(audienceKeys.join("\n"), 4));
+    }
+}
+_define_property(AudiencePush, "summary", "Push one or more audiences from a local file system to Knock.");
+_define_property(AudiencePush, "flags", {
+    environment: _core.Flags.string({
+        summary: "The environment to push the audience to. Defaults to development.",
+        default: _const.KnockEnv.Development
+    }),
+    branch: _flag.branch,
+    all: _core.Flags.boolean({
+        summary: "Whether to push all audiences from the target directory."
+    }),
+    "audiences-dir": _flag.dirPath({
+        summary: "The target directory path to find all audiences to push.",
+        dependsOn: [
+            "all"
+        ]
+    }),
+    commit: _core.Flags.boolean({
+        summary: "Push and commit the audience(s) at the same time"
+    }),
+    "commit-message": _core.Flags.string({
+        summary: "Use the given value as the commit message",
+        char: "m",
+        dependsOn: [
+            "commit"
+        ]
+    })
+});
+_define_property(AudiencePush, "args", {
+    audienceKey: _core.Args.string({
+        required: false
+    })
+});

package/dist/commands/audience/validate.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return AudienceValidate;
+    }
+});
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _command = require("../../lib/helpers/command");
+const _const = require("../../lib/helpers/const");
+const _error = require("../../lib/helpers/error");
+const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
+const _string = require("../../lib/helpers/string");
+const _ux = require("../../lib/helpers/ux");
+const _audience = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/audience"));
+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 AudienceValidate extends _basecommand.default {
+    async run() {
+        // 1. Read all audience directories found for the given command.
+        const target = await _audience.ensureValidCommandTarget(this.props, this.runContext, this.projectConfig);
+        const [audiences, readErrors] = await _audience.readAllForCommandTarget(target);
+        if (readErrors.length > 0) {
+            this.error((0, _error.formatErrors)(readErrors, {
+                prependBy: "\n\n"
+            }));
+        }
+        if (audiences.length === 0) {
+            this.error(`No audience directories found in ${target.context.abspath}`);
+        }
+        // 2. Validate each audience data.
+        _ux.spinner.start(`‣ Validating`);
+        const apiErrors = await AudienceValidate.validateAll(this.apiV1, this.props, audiences);
+        if (apiErrors.length > 0) {
+            this.error((0, _error.formatErrors)(apiErrors, {
+                prependBy: "\n\n"
+            }));
+        }
+        _ux.spinner.stop();
+        // 3. Display a success message.
+        const audienceKeys = audiences.map((a)=>a.key);
+        const scope = (0, _command.formatCommandScope)({
+            ...this.props.flags
+        });
+        this.log(`‣ Successfully validated ${audiences.length} audience(s) using ${scope}:\n` + (0, _string.indentString)(audienceKeys.join("\n"), 4));
+    }
+    static async validateAll(api, props, audiences) {
+        const { flags } = props;
+        const errorPromises = audiences.map(async (audience)=>{
+            try {
+                await api.mgmtClient.audiences.validate(audience.key, {
+                    environment: flags.environment,
+                    branch: flags.branch,
+                    audience: audience.content
+                });
+                return;
+            } catch (error) {
+                return new _error.SourceError(error.message, _audience.audienceJsonPath(audience), "ApiError");
+            }
+        });
+        const errors = (await Promise.all(errorPromises)).filter((e)=>Boolean(e));
+        return errors;
+    }
+}
+_define_property(AudienceValidate, "summary", "Validate one or more audiences from a local file system.");
+_define_property(AudienceValidate, "flags", {
+    environment: _core.Flags.string({
+        summary: "The environment to validate the audience against. Defaults to development.",
+        default: _const.KnockEnv.Development
+    }),
+    branch: _flag.branch,
+    all: _core.Flags.boolean({
+        summary: "Whether to validate all audiences from the target directory."
+    }),
+    "audiences-dir": _flag.dirPath({
+        summary: "The target directory path to find all audiences to validate.",
+        dependsOn: [
+            "all"
+        ]
+    })
+});
+_define_property(AudienceValidate, "args", {
+    audienceKey: _core.Args.string({
+        required: false
+    })
+});