@knocklabs/cli 1.0.0 → 1.0.2

package/dist/commands/audience/archive.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return AudienceArchive;
+    }
+});
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _error = require("../../lib/helpers/error");
+const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
+const _ux = require("../../lib/helpers/ux");
+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 AudienceArchive extends _basecommand.default {
+    async run() {
+        const { audienceKey } = this.props.args;
+        const { force, environment } = this.props.flags;
+        // Confirm before archiving since this affects all environments
+        if (!force) {
+            const confirmed = await (0, _ux.promptToConfirm)(`WARNING: Archiving audience \`${audienceKey}\` will affect ALL environments.\n` + `This action cannot be undone. Continue?`);
+            if (!confirmed) {
+                this.log("Archive cancelled.");
+                return;
+            }
+        }
+        _ux.spinner.start(`‣ Archiving audience \`${audienceKey}\``);
+        try {
+            await this.apiV1.mgmtClient.audiences.archive(audienceKey, {
+                environment
+            });
+            _ux.spinner.stop();
+            this.log(`‣ Successfully archived audience \`${audienceKey}\` across all environments.`);
+        } catch (error) {
+            _ux.spinner.stop();
+            _core.ux.error(new _error.ApiError(error.message));
+        }
+    }
+}
+_define_property(AudienceArchive, "summary", "Archive an audience (affects ALL environments).");
+_define_property(AudienceArchive, "description", `
+WARNING: Archiving an audience affects ALL environments and cannot be undone.
+Use this command with caution.
+`);
+_define_property(AudienceArchive, "flags", {
+    environment: _core.Flags.string({
+        required: true,
+        summary: "The environment to use."
+    }),
+    branch: _flag.branch,
+    force: _core.Flags.boolean({
+        summary: "Skip confirmation prompt."
+    })
+});
+_define_property(AudienceArchive, "args", {
+    audienceKey: _core.Args.string({
+        required: true,
+        description: "The key of the audience to archive."
+    })
+});

package/dist/commands/audience/get.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return AudienceGet;
+    }
+});
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _command = require("../../lib/helpers/command");
+const _date = require("../../lib/helpers/date");
+const _error = require("../../lib/helpers/error");
+const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
+const _ux = require("../../lib/helpers/ux");
+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 AudienceGet extends _basecommand.default {
+    async run() {
+        _ux.spinner.start("‣ Loading");
+        const { audience } = await this.loadAudience();
+        _ux.spinner.stop();
+        const { flags } = this.props;
+        if (flags.json) return audience;
+        this.render(audience);
+    }
+    async loadAudience() {
+        const { audienceKey } = this.props.args;
+        const { flags } = this.props;
+        try {
+            const audience = await this.apiV1.mgmtClient.audiences.retrieve(audienceKey, {
+                environment: flags.environment,
+                branch: flags.branch,
+                hide_uncommitted_changes: flags["hide-uncommitted-changes"]
+            });
+            return {
+                audience
+            };
+        } catch (error) {
+            _core.ux.error(new _error.ApiError(error.message));
+        }
+    }
+    render(audience) {
+        const { audienceKey } = this.props.args;
+        const { environment: env, "hide-uncommitted-changes": committedOnly } = this.props.flags;
+        const qualifier = env === "development" && !committedOnly ? "(including uncommitted)" : "";
+        const scope = (0, _command.formatCommandScope)(this.props.flags);
+        this.log(`‣ Showing audience \`${audienceKey}\` in ${scope} ${qualifier}\n`);
+        /*
+     * Audience table
+     */ const rows = [
+            {
+                key: "Name",
+                value: audience.name
+            },
+            {
+                key: "Key",
+                value: audience.key
+            },
+            {
+                key: "Type",
+                value: audience.type
+            },
+            {
+                key: "Description",
+                value: audience.description || "-"
+            },
+            {
+                key: "Created at",
+                value: (0, _date.formatDateTime)(audience.created_at)
+            },
+            {
+                key: "Updated at",
+                value: (0, _date.formatDateTime)(audience.updated_at)
+            }
+        ];
+        _core.ux.table(rows, {
+            key: {
+                header: "Audience",
+                minWidth: 24
+            },
+            value: {
+                header: "",
+                minWidth: 24
+            }
+        });
+        // Show segments for dynamic audiences
+        if (audience.type === "dynamic" && audience.segments) {
+            this.log("\nSegments:");
+            this.log(JSON.stringify(audience.segments, null, 2));
+        }
+    }
+}
+_define_property(AudienceGet, "summary", "Display a single audience from an environment.");
+_define_property(AudienceGet, "flags", {
+    environment: _core.Flags.string({
+        default: "development",
+        summary: "The environment to use."
+    }),
+    branch: _flag.branch,
+    "hide-uncommitted-changes": _core.Flags.boolean({
+        summary: "Hide any uncommitted changes."
+    })
+});
+_define_property(AudienceGet, "args", {
+    audienceKey: _core.Args.string({
+        required: true
+    })
+});
+_define_property(AudienceGet, "enableJsonFlag", true);

package/dist/commands/audience/list.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return AudienceList;
+    }
+});
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _command = require("../../lib/helpers/command");
+const _date = require("../../lib/helpers/date");
+const _error = require("../../lib/helpers/error");
+const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
+const _page = require("../../lib/helpers/page");
+const _ux = require("../../lib/helpers/ux");
+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 AudienceList extends _basecommand.default {
+    async run() {
+        const data = await this.request();
+        const { flags } = this.props;
+        if (flags.json) return data;
+        return this.render(data);
+    }
+    async request(pageParams = {}) {
+        const { flags } = this.props;
+        _ux.spinner.start("‣ Loading");
+        try {
+            var _pageParams_after, _pageParams_before;
+            const page = await this.apiV1.mgmtClient.audiences.list({
+                environment: flags.environment,
+                branch: flags.branch,
+                hide_uncommitted_changes: flags["hide-uncommitted-changes"],
+                limit: flags.limit,
+                after: (_pageParams_after = pageParams.after) !== null && _pageParams_after !== void 0 ? _pageParams_after : flags.after,
+                before: (_pageParams_before = pageParams.before) !== null && _pageParams_before !== void 0 ? _pageParams_before : flags.before
+            });
+            _ux.spinner.stop();
+            return {
+                entries: page.entries,
+                page_info: page.page_info
+            };
+        } catch (error) {
+            _ux.spinner.stop();
+            throw new _error.ApiError(error.message);
+        }
+    }
+    async render(data) {
+        const { entries } = data;
+        const { environment: env, "hide-uncommitted-changes": committedOnly } = this.props.flags;
+        const qualifier = env === "development" && !committedOnly ? "(including uncommitted)" : "";
+        const scope = (0, _command.formatCommandScope)(this.props.flags);
+        this.log(`‣ Showing ${entries.length} audiences in ${scope} ${qualifier}\n`);
+        /*
+     * Audiences list table
+     */ _core.ux.table(entries, {
+            key: {
+                header: "Key"
+            },
+            name: {
+                header: "Name"
+            },
+            description: {
+                header: "Description"
+            },
+            type: {
+                header: "Type"
+            },
+            updated_at: {
+                header: "Updated at",
+                get: (entry)=>(0, _date.formatDate)(entry.updated_at)
+            }
+        });
+        return this.prompt(data);
+    }
+    async prompt(data) {
+        const { page_info } = data;
+        const pageAction = await (0, _page.maybePromptPageAction)(page_info);
+        const pageParams = pageAction && (0, _page.paramsForPageAction)(pageAction, page_info);
+        if (pageParams) {
+            this.log("\n");
+            const nextData = await this.request(pageParams);
+            return this.render(nextData);
+        }
+    }
+}
+_define_property(AudienceList, "summary", "Display all audiences for an environment.");
+_define_property(AudienceList, "flags", {
+    environment: _core.Flags.string({
+        default: "development",
+        summary: "The environment to use."
+    }),
+    branch: _flag.branch,
+    "hide-uncommitted-changes": _core.Flags.boolean({
+        summary: "Hide any uncommitted changes."
+    }),
+    ..._page.pageFlags
+});
+_define_property(AudienceList, "enableJsonFlag", true);

package/dist/commands/audience/new.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return AudienceNew;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+const _core = require("@oclif/core");
+const _enquirer = require("enquirer");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _const = require("../../lib/helpers/const");
+const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
+const _projectconfig = require("../../lib/helpers/project-config");
+const _string = require("../../lib/helpers/string");
+const _ux = require("../../lib/helpers/ux");
+const _audience = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/audience"));
+const _push = /*#__PURE__*/ _interop_require_default(require("./push"));
+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;
+}
+const AUDIENCE_TYPE_CHOICES = [
+    {
+        name: _audience.AudienceType.Static,
+        message: "Static (manual membership)"
+    },
+    {
+        name: _audience.AudienceType.Dynamic,
+        message: "Dynamic (rule-based membership) [Beta - requires access]"
+    }
+];
+class AudienceNew extends _basecommand.default {
+    async run() {
+        const { flags } = this.props;
+        const { resourceDir } = this.runContext;
+        // 1. Ensure we aren't in any existing resource directory already.
+        if (resourceDir) {
+            return this.error(`Cannot create a new audience inside an existing ${resourceDir.type} directory`);
+        }
+        // 2. Prompt for name and key if not provided
+        let name = flags.name;
+        let key = flags.key;
+        if (!name) {
+            const nameResponse = await (0, _enquirer.prompt)({
+                type: "input",
+                name: "name",
+                message: "Audience name",
+                validate: (value)=>{
+                    if (!value || value.trim().length === 0) {
+                        return "Audience name is required";
+                    }
+                    return true;
+                }
+            });
+            name = nameResponse.name;
+        }
+        if (!key) {
+            const keyResponse = await (0, _enquirer.prompt)({
+                type: "input",
+                name: "key",
+                message: "Audience key (immutable slug)",
+                initial: (0, _string.slugify)(name),
+                validate: (value)=>{
+                    if (!value || value.trim().length === 0) {
+                        return "Audience key is required";
+                    }
+                    const keyError = _audience.validateAudienceKey(value);
+                    if (keyError) {
+                        return `Invalid audience key: ${keyError}`;
+                    }
+                    return true;
+                }
+            });
+            key = keyResponse.key;
+        }
+        // Validate the audience key
+        const audienceKeyError = _audience.validateAudienceKey(key);
+        if (audienceKeyError) {
+            return this.error(`Invalid audience key \`${key}\` (${audienceKeyError})`);
+        }
+        const audienceDirCtx = await this.getAudienceDirContext(key);
+        const promptMessage = audienceDirCtx.exists ? `Found \`${audienceDirCtx.key}\` at ${audienceDirCtx.abspath}, overwrite?` : `Create a new audience directory \`${audienceDirCtx.key}\` at ${audienceDirCtx.abspath}?`;
+        // Check if the audience directory already exists, and prompt to confirm if not.
+        const input = flags.force || await (0, _ux.promptToConfirm)(promptMessage);
+        if (!input) return;
+        // 3. Prompt for type if not provided
+        let audienceType;
+        if (flags.type) {
+            audienceType = flags.type;
+        } else {
+            const typeResponse = await (0, _enquirer.prompt)({
+                type: "select",
+                name: "type",
+                message: "Select audience type",
+                choices: AUDIENCE_TYPE_CHOICES.map((choice)=>({
+                        name: choice.name,
+                        message: choice.message
+                    }))
+            });
+            audienceType = typeResponse.type;
+        }
+        // Generate the audience directory with scaffolded content
+        await _audience.generateAudienceDir(audienceDirCtx, {
+            name,
+            type: audienceType,
+            description: flags.description
+        });
+        if (flags.push) {
+            _ux.spinner.start("‣ Pushing audience to Knock");
+            const pushArgs = [
+                key,
+                "--environment",
+                flags.environment
+            ];
+            if (flags.branch) {
+                pushArgs.push("--branch", flags.branch);
+            }
+            try {
+                await _push.default.run(pushArgs);
+            } catch (error) {
+                this.error(`Failed to push audience to Knock: ${error}`);
+            } finally{
+                _ux.spinner.stop();
+            }
+        }
+        this.log(`‣ Successfully created audience \`${key}\``);
+    }
+    async getAudienceDirContext(audienceKey) {
+        const { cwd: runCwd } = this.runContext;
+        // Default to knock project config first if present, otherwise cwd.
+        const dirCtx = 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(dirCtx.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(AudienceNew, "summary", "Create a new audience with a minimal configuration.");
+_define_property(AudienceNew, "flags", {
+    name: _core.Flags.string({
+        summary: "The name of the audience",
+        char: "n"
+    }),
+    key: _core.Flags.string({
+        summary: "The key of the audience",
+        char: "k"
+    }),
+    type: _core.Flags.string({
+        summary: "The type of the audience (static, dynamic). Note: dynamic is in beta and requires access.",
+        char: "t",
+        options: [
+            _audience.AudienceType.Static,
+            _audience.AudienceType.Dynamic
+        ]
+    }),
+    description: _core.Flags.string({
+        summary: "The description of the audience",
+        char: "d"
+    }),
+    environment: _core.Flags.string({
+        summary: "The environment to create the audience in. Defaults to development.",
+        default: _const.KnockEnv.Development
+    }),
+    branch: _flag.branch,
+    force: _core.Flags.boolean({
+        summary: "Force the creation of the audience directory without confirmation."
+    }),
+    push: _core.Flags.boolean({
+        summary: "Whether or not to push the audience to Knock after creation.",
+        default: false,
+        char: "p"
+    })
+});
+_define_property(AudienceNew, "args", {});