@knocklabs/cli 0.3.0 → 1.0.0-rc.1

package/dist/commands/branch/create.js

@@ -44,8 +44,6 @@ class BranchCreate extends _basecommand.default {
         this.log(`  Created at: ${data.created_at}`);
     }
 }
-// Hide until branches are released in GA
-_define_property(BranchCreate, "hidden", true);
 _define_property(BranchCreate, "summary", "Creates a new branch off of the development environment.");
 _define_property(BranchCreate, "enableJsonFlag", true);
 _define_property(BranchCreate, "args", {

package/dist/commands/branch/delete.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "default", {
 const _core = require("@oclif/core");
 const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
 const _arg = require("../../lib/helpers/arg");
+const _const = require("../../lib/helpers/const");
 const _request = require("../../lib/helpers/request");
 const _ux = require("../../lib/helpers/ux");
 function _define_property(obj, key, value) {
@@ -38,14 +39,14 @@ class BranchDelete extends _basecommand.default {
         const prompt = `Delete branch \`${args.slug}\`?`;
         const input = flags.force || await (0, _ux.promptToConfirm)(prompt);
         if (!input) return;
-        await (0, _request.withSpinnerV2)(()=>this.apiV1.mgmtClient.delete(`/v1/branches/${args.slug}`), {
+        await (0, _request.withSpinnerV2)(()=>this.apiV1.mgmtClient.branches.delete(args.slug, {
+                environment: _const.KnockEnv.Development
+            }), {
             action: "‣ Deleting branch"
         });
         this.log(`‣ Successfully deleted branch \`${args.slug}\``);
     }
 }
-// Hide until branches are released in GA
-_define_property(BranchDelete, "hidden", true);
 _define_property(BranchDelete, "summary", "Deletes an existing branch with the given slug.");
 _define_property(BranchDelete, "args", {
     slug: _arg.CustomArgs.slug({

package/dist/commands/branch/exit.js

@@ -39,6 +39,4 @@ class BranchExit extends _basecommand.default {
         this.log("‣ Successfully exited the branch");
     }
 }
-// Hide until branches are released in GA
-_define_property(BranchExit, "hidden", true);
 _define_property(BranchExit, "summary", "Exits the current branch.");

package/dist/commands/branch/list.js

@@ -80,8 +80,6 @@ class BranchList extends _basecommand.default {
         }
     }
 }
-// Hide until branches are released in GA
-_define_property(BranchList, "hidden", true);
 _define_property(BranchList, "summary", "Display all existing branches off of the development environment.");
 _define_property(BranchList, "flags", {
     ..._page.pageFlags

package/dist/commands/branch/merge.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return BranchMerge;
+    }
+});
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _arg = require("../../lib/helpers/arg");
+const _const = require("../../lib/helpers/const");
+const _request = require("../../lib/helpers/request");
+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
+    };
+}
+class BranchMerge extends _basecommand.default {
+    async run() {
+        const { args, flags } = this.props;
+        const promotePrompt = `Merge all changes from branch \`${args.slug}\` into the development environment?`;
+        const shouldPromote = flags.force || await (0, _ux.promptToConfirm)(promotePrompt);
+        if (!shouldPromote) return;
+        await this.promoteBranchCommits();
+        if (!flags.delete) return;
+        const deletePrompt = `Delete branch \`${args.slug}\`?`;
+        const shouldDelete = flags.force || await (0, _ux.promptToConfirm)(deletePrompt);
+        if (!shouldDelete) return;
+        await this.deleteBranch();
+    }
+    async promoteBranchCommits() {
+        const { args } = this.props;
+        await (0, _request.withSpinnerV2)(()=>this.apiV1.mgmtClient.commits.promoteAll({
+                branch: args.slug,
+                to_environment: _const.KnockEnv.Development
+            }));
+        this.log(`‣ Successfully merged all changes into the development environment`);
+    }
+    async deleteBranch() {
+        const { args } = this.props;
+        await (0, _request.withSpinnerV2)(()=>this.apiV1.mgmtClient.branches.delete(args.slug, {
+                environment: _const.KnockEnv.Development
+            }), {
+            action: "‣ Deleting branch"
+        });
+        this.log(`‣ Successfully deleted branch \`${args.slug}\``);
+    }
+}
+_define_property(BranchMerge, "summary", "Merges a branch into the development environment.");
+_define_property(BranchMerge, "args", {
+    slug: _arg.CustomArgs.slug({
+        required: true,
+        description: "The slug of the branch to merge"
+    })
+});
+_define_property(BranchMerge, "flags", {
+    force: _core.Flags.boolean({
+        summary: "Remove the confirmation prompt."
+    }),
+    delete: _core.Flags.boolean({
+        summary: "Delete the branch after merging.",
+        default: true,
+        allowNo: true
+    })
+});

package/dist/commands/branch/switch.js

@@ -142,8 +142,6 @@ class BranchSwitch extends _basecommand.default {
         });
     }
 }
-// Hide until branches are released in GA
-_define_property(BranchSwitch, "hidden", true);
 _define_property(BranchSwitch, "summary", "Switches to an existing branch with the given slug.");
 _define_property(BranchSwitch, "flags", {
     create: _core.Flags.boolean({

package/dist/commands/channel/list.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return ChannelList;
+    }
+});
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _date = require("../../lib/helpers/date");
+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
+    };
+}
+class ChannelList extends _basecommand.default {
+    async run() {
+        const channels = await this.request();
+        const { flags } = this.props;
+        if (flags.json) return channels;
+        await this.render(channels);
+    }
+    async request() {
+        return this.apiV1.listAllChannels();
+    }
+    async render(channels) {
+        this.log(`‣ Showing ${channels.length} channels\n`);
+        /*
+     * Channels list table
+     */ const formattedChannels = channels.map((channel)=>({
+                key: channel.key,
+                name: channel.name,
+                type: channel.type,
+                provider: channel.provider,
+                updated_at: (0, _date.formatDate)(channel.updated_at)
+            }));
+        _core.ux.table(formattedChannels, {
+            key: {
+                header: "Key"
+            },
+            name: {
+                header: "Name"
+            },
+            type: {
+                header: "Type"
+            },
+            provider: {
+                header: "Provider"
+            },
+            updated_at: {
+                header: "Updated at"
+            }
+        });
+    }
+}
+_define_property(ChannelList, "summary", "Display all channels configured for the account.");
+_define_property(ChannelList, "enableJsonFlag", true);

package/dist/commands/environment/list.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return EnvironmentList;
+    }
+});
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _date = require("../../lib/helpers/date");
+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
+    };
+}
+class EnvironmentList extends _basecommand.default {
+    async run() {
+        const environments = await this.request();
+        const { flags } = this.props;
+        if (flags.json) return environments;
+        await this.render(environments);
+    }
+    async request() {
+        return this.apiV1.listAllEnvironments();
+    }
+    async render(environments) {
+        this.log(`‣ Showing ${environments.length} environments\n`);
+        /*
+     * Environments list table
+     */ const formattedEnvironments = environments.map((environment)=>({
+                slug: environment.slug,
+                name: environment.name,
+                order: environment.order,
+                owner: environment.owner,
+                updated_at: (0, _date.formatDate)(environment.updated_at)
+            }));
+        _core.ux.table(formattedEnvironments, {
+            slug: {
+                header: "Slug"
+            },
+            name: {
+                header: "Name"
+            },
+            order: {
+                header: "Order"
+            },
+            owner: {
+                header: "Owner"
+            },
+            updated_at: {
+                header: "Updated at"
+            }
+        });
+    }
+}
+_define_property(EnvironmentList, "summary", "Display all environments configured for the account.");
+_define_property(EnvironmentList, "enableJsonFlag", true);

package/dist/commands/guide/new.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return GuideNew;
+    }
+});
+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 _guide = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/guide"));
+const _runcontext = require("../../lib/run-context");
+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;
+}
+class GuideNew 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 guide inside an existing ${resourceDir.type} directory`);
+        }
+        // 2. Validate that template and message-type flags are not used together
+        if (flags.template && flags["message-type"]) {
+            return this.error("Cannot use both --template and --message-type flags together");
+        }
+        // 3. 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: "Guide name",
+                validate: (value)=>{
+                    if (!value || value.trim().length === 0) {
+                        return "Guide name is required";
+                    }
+                    return true;
+                }
+            });
+            name = nameResponse.name;
+        }
+        if (!key) {
+            const keyResponse = await (0, _enquirer.prompt)({
+                type: "input",
+                name: "key",
+                message: "Guide key (immutable slug)",
+                initial: (0, _string.slugify)(name),
+                validate: (value)=>{
+                    if (!value || value.trim().length === 0) {
+                        return "Guide key is required";
+                    }
+                    const keyError = _guide.validateGuideKey(value);
+                    if (keyError) {
+                        return `Invalid guide key: ${keyError}`;
+                    }
+                    return true;
+                }
+            });
+            key = keyResponse.key;
+        }
+        // Validate the guide key
+        const guideKeyError = _guide.validateGuideKey(key);
+        if (guideKeyError) {
+            return this.error(`Invalid guide key \`${key}\` (${guideKeyError})`);
+        }
+        const guideDirCtx = await this.getGuideDirContext(key);
+        const promptMessage = guideDirCtx.exists ? `Found \`${guideDirCtx.key}\` at ${guideDirCtx.abspath}, overwrite?` : `Create a new guide directory \`${guideDirCtx.key}\` at ${guideDirCtx.abspath}?`;
+        // Check if the guide directory already exists, and prompt to confirm if not. Prompt to overwrite if it does.
+        const input = flags.force || await (0, _ux.promptToConfirm)(promptMessage);
+        if (!input) return;
+        // Generate the guide either from a template or from scratch
+        await (flags.template ? this.fromTemplate(guideDirCtx, name, flags.template) : this.fromMessageType(guideDirCtx, name, flags["message-type"]));
+        if (flags.push) {
+            _ux.spinner.start("‣ Pushing guide to Knock");
+            try {
+                await _push.default.run([
+                    key
+                ]);
+            } catch (error) {
+                this.error(`Failed to push guide to Knock: ${error}`);
+            } finally{
+                _ux.spinner.stop();
+            }
+        }
+        this.log(`‣ Successfully created guide \`${key}\``);
+    }
+    async fromTemplate(guideDirCtx, name, templateString) {
+        // When being called from the template string, we want to try and generate
+        // the guide from the provided template.
+        _ux.spinner.start(`‣ Generating guide from template \`${templateString}\``);
+        try {
+            await _guide.generateGuideFromTemplate(guideDirCtx, templateString, {
+                name
+            });
+        } catch (error) {
+            this.error(`Failed to generate guide from template: ${error}`);
+        } finally{
+            _ux.spinner.stop();
+        }
+    }
+    async fromMessageType(guideDirCtx, name, messageTypeKey) {
+        const { flags } = this.props;
+        _ux.spinner.start(`‣ Fetching message types`);
+        // Fetch all message types from the API
+        const messageTypes = await this.apiV1.listAllMessageTypes({
+            environment: flags.environment,
+            hide_uncommitted_changes: true
+        });
+        _ux.spinner.stop();
+        if (messageTypes.length === 0) {
+            return this.error("No message types found. Please create a message type first.");
+        }
+        let selectedMessageType;
+        // Determine message type from flag or prompt
+        if (messageTypeKey) {
+            const messageType = messageTypes.find((mt)=>mt.key === messageTypeKey);
+            if (!messageType) {
+                return this.error(`Message type \`${messageTypeKey}\` not found`);
+            }
+            selectedMessageType = messageType;
+        } else {
+            // Prompt for message type with select
+            const messageTypeChoices = messageTypes.map((mt)=>({
+                    name: mt.key,
+                    message: `${mt.name} (${mt.key})`
+                }));
+            const messageTypeResponse = await (0, _enquirer.prompt)({
+                type: "select",
+                name: "messageType",
+                message: "Select message type",
+                choices: messageTypeChoices
+            });
+            const messageType = messageTypes.find((mt)=>mt.key === messageTypeResponse.messageType);
+            if (!messageType) {
+                return this.error("Message type selection failed");
+            }
+            selectedMessageType = messageType;
+        }
+        // Generate the guide directory with scaffolded content
+        await _guide.generateGuideDir(guideDirCtx, {
+            name,
+            messageType: selectedMessageType,
+            variantKey: "default"
+        });
+    }
+    async getGuideDirContext(guideKey) {
+        const { resourceDir, cwd: runCwd } = this.runContext;
+        // Inside an existing resource dir, use it if valid for the target guide.
+        if (resourceDir) {
+            const target = {
+                commandId: _basecommand.default.id,
+                type: "guide",
+                key: guideKey
+            };
+            return (0, _runcontext.ensureResourceDirForTarget)(resourceDir, target);
+        }
+        // Default to knock project config first if present, otherwise cwd.
+        const dirCtx = await (0, _projectconfig.resolveResourceDir)(this.projectConfig, "guide", runCwd);
+        // Not inside any existing guide directory, which means either create a
+        // new guide directory in the cwd, or update it if there is one already.
+        if (guideKey) {
+            const dirPath = _nodepath.resolve(dirCtx.abspath, guideKey);
+            const exists = await _guide.isGuideDir(dirPath);
+            return {
+                type: "guide",
+                key: guideKey,
+                abspath: dirPath,
+                exists
+            };
+        }
+        // Not in any guide directory, nor a guide key arg was given so error.
+        return this.error("Missing 1 required arg:\nguideKey");
+    }
+}
+_define_property(GuideNew, "summary", "Create a new guide with a minimal configuration.");
+_define_property(GuideNew, "flags", {
+    name: _core.Flags.string({
+        summary: "The name of the guide",
+        char: "n"
+    }),
+    key: _core.Flags.string({
+        summary: "The key of the guide",
+        char: "k"
+    }),
+    "message-type": _core.Flags.string({
+        summary: "The message type key to use for the guide. You cannot use this flag with --template.",
+        char: "m"
+    }),
+    environment: _core.Flags.string({
+        summary: "The environment to create the guide in. Defaults to development.",
+        default: _const.KnockEnv.Development
+    }),
+    branch: _flag.branch,
+    force: _core.Flags.boolean({
+        summary: "Force the creation of the guide directory without confirmation."
+    }),
+    push: _core.Flags.boolean({
+        summary: "Whether or not to push the guide to Knock after creation.",
+        default: false,
+        char: "p"
+    }),
+    template: _core.Flags.string({
+        summary: "The template to use for the guide. Should be `guides/{key}`. You cannot use this flag with --message-type.",
+        char: "t"
+    })
+});
+_define_property(GuideNew, "args", {});

package/dist/commands/guide/pull.js

@@ -16,6 +16,7 @@ const _error = require("../../lib/helpers/error");
 const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
 const _objectisomorphic = require("../../lib/helpers/object.isomorphic");
 const _page = require("../../lib/helpers/page");
+const _projectconfig = require("../../lib/helpers/project-config");
 const _request = require("../../lib/helpers/request");
 const _ux = require("../../lib/helpers/ux");
 const _guide = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/guide"));
@@ -117,11 +118,8 @@ class GuidePull extends _basecommand.default {
     }
     async pullAllGuides() {
         const { flags } = this.props;
-        const defaultToCwd = {
-            abspath: this.runContext.cwd,
-            exists: true
-        };
-        const targetDirCtx = flags["guides-dir"] || defaultToCwd;
+        const guidesIndexDirCtx = await (0, _projectconfig.resolveResourceDir)(this.projectConfig, "guide", this.runContext.cwd);
+        const targetDirCtx = flags["guides-dir"] || guidesIndexDirCtx;
         const prompt = targetDirCtx.exists ? `Pull latest guides into ${targetDirCtx.abspath}?\n  This will overwrite the contents of this directory.` : `Create a new guides directory at ${targetDirCtx.abspath}?`;
         const input = flags.force || await (0, _ux.promptToConfirm)(prompt);
         if (!input) return;
@@ -169,10 +167,11 @@ class GuidePull extends _basecommand.default {
             };
             return (0, _runcontext.ensureResourceDirForTarget)(resourceDir, target);
         }
+        const guidesIndexDirCtx = await (0, _projectconfig.resolveResourceDir)(this.projectConfig, "guide", runCwd);
         // Not inside any existing guide directory, which means either create a
         // new guide directory in the cwd, or update it if there is one already.
         if (guideKey) {
-            const dirPath = _nodepath.resolve(runCwd, guideKey);
+            const dirPath = _nodepath.resolve(guidesIndexDirCtx.abspath, guideKey);
             const exists = await _guide.isGuideDir(dirPath);
             return {
                 type: "guide",

package/dist/commands/guide/push.js

@@ -83,7 +83,7 @@ class GuidePush extends _basecommand.default {
     async run() {
         const { flags } = this.props;
         // 1. First read all guide directories found for the given command.
-        const target = await _guide.ensureValidCommandTarget(this.props, this.runContext);
+        const target = await _guide.ensureValidCommandTarget(this.props, this.runContext, this.projectConfig);
         const [guides, readErrors] = await _guide.readAllForCommandTarget(target, {
             withExtractedFiles: true
         });

package/dist/commands/guide/validate.js

@@ -80,7 +80,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
 class GuideValidate extends _basecommand.default {
     async run() {
         // 1. Read all guide directories found for the given command.
-        const target = await _guide.ensureValidCommandTarget(this.props, this.runContext);
+        const target = await _guide.ensureValidCommandTarget(this.props, this.runContext, this.projectConfig);
         const [guides, readErrors] = await _guide.readAllForCommandTarget(target, {
             withExtractedFiles: true
         });