@knocklabs/cli 0.3.0 → 1.0.0-rc.1

package/dist/commands/workflow/new.js

@@ -10,11 +10,17 @@ Object.defineProperty(exports, "default", {
 });
 const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
 const _core = require("@oclif/core");
-const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+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 _workflow = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/workflow"));
+const _generator = require("../../lib/marshal/workflow/generator");
+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, {
@@ -76,75 +82,194 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 class WorkflowNew extends _basecommand.default {
     async run() {
-        const { args, flags } = this.props;
-        const { cwd, resourceDir } = this.runContext;
-        _ux.spinner.start("‣ Validating");
+        const { flags } = this.props;
+        const { resourceDir } = this.runContext;
         // 1. Ensure we aren't in any existing resource directory already.
-        // TODO: In the future, maybe check for the project context and if we are in
-        // /workflows directory.
         if (resourceDir) {
-            return this.error(`Cannot generate inside an existing ${resourceDir.type} directory`);
+            return this.error(`Cannot create a new workflow inside an existing ${resourceDir.type} directory`);
         }
-        // 2. Ensure the workflow key is in the valid format.
-        const workflowKeyError = _workflow.validateWorkflowKey(args.workflowKey);
+        // 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: "Workflow name",
+                validate: (value)=>{
+                    if (!value || value.trim().length === 0) {
+                        return "Workflow name is required";
+                    }
+                    return true;
+                }
+            });
+            name = nameResponse.name;
+        }
+        if (!key) {
+            const keyResponse = await (0, _enquirer.prompt)({
+                type: "input",
+                name: "key",
+                message: "Workflow key (immutable slug)",
+                initial: (0, _string.slugify)(name),
+                validate: (value)=>{
+                    if (!value || value.trim().length === 0) {
+                        return "Workflow key is required";
+                    }
+                    const keyError = _workflow.validateWorkflowKey(value);
+                    if (keyError) {
+                        return `Invalid workflow key: ${keyError}`;
+                    }
+                    return true;
+                }
+            });
+            key = keyResponse.key;
+        }
+        // Validate the workflow key
+        const workflowKeyError = _workflow.validateWorkflowKey(key);
         if (workflowKeyError) {
-            return this.error(`Invalid workflow key \`${args.workflowKey}\` (${workflowKeyError})`);
+            return this.error(`Invalid workflow key \`${key}\` (${workflowKeyError})`);
         }
-        // 3. Parse and validate the steps flag, if given.
-        const [steps, stepsError] = _workflow.parseStepsInput(flags.steps || "");
-        if (stepsError) {
-            return this.error(`Invalid --steps \`${flags.steps}\` (${stepsError})`);
+        const workflowDirCtx = await this.getWorkflowDirContext(key);
+        const promptMessage = workflowDirCtx.exists ? `Found \`${workflowDirCtx.key}\` at ${workflowDirCtx.abspath}, overwrite?` : `Create a new workflow directory \`${workflowDirCtx.key}\` at ${workflowDirCtx.abspath}?`;
+        // Check if the workflow directory already exists, and prompt to confirm if not.
+        const input = flags.force || await (0, _ux.promptToConfirm)(promptMessage);
+        if (!input) return;
+        // Generate the workflow either from a template or from scratch
+        await (flags.template ? this.fromTemplate(workflowDirCtx, name, flags.template) : this.fromSteps(workflowDirCtx, name, flags.steps));
+        if (flags.push) {
+            _ux.spinner.start("‣ Pushing workflow to Knock");
+            try {
+                await _push.default.run([
+                    key
+                ]);
+            } catch (error) {
+                this.error(`Failed to push workflow to Knock: ${error}`);
+            } finally{
+                _ux.spinner.stop();
+            }
         }
-        // 4. Ensure not to overwrite any existing path accidentally.
-        const newWorkflowDirPath = _nodepath.resolve(cwd, args.workflowKey);
-        const pathExists = await _fsextra.pathExists(newWorkflowDirPath);
-        if (pathExists && !flags.force) {
-            return this.error(`Cannot overwrite an existing path at ${newWorkflowDirPath}` + " (use --force to overwrite)");
+        this.log(`‣ Successfully created workflow \`${key}\``);
+    }
+    async fromTemplate(workflowDirCtx, name, templateString) {
+        // When being called from the template string, we want to try and generate
+        // the workflow from the provided template.
+        const channelsByType = await this.listAllChannelsByType();
+        _ux.spinner.start(`‣ Generating workflow from template \`${templateString}\``);
+        try {
+            await _workflow.generateWorkflowFromTemplate(workflowDirCtx, templateString, {
+                name
+            }, channelsByType);
+        } catch (error) {
+            this.error(`Failed to generate workflow from template: ${error}`);
+        } finally{
+            _ux.spinner.stop();
         }
-        _ux.spinner.stop();
-        // 5-A. We are good to generate a new workflow directory.
-        const dirContext = {
-            type: "workflow",
-            key: args.workflowKey,
-            abspath: newWorkflowDirPath,
-            exists: await _workflow.isWorkflowDir(newWorkflowDirPath)
-        };
-        const attrs = {
-            name: args.workflowKey,
+    }
+    async fromSteps(workflowDirCtx, name, stepStr) {
+        const channelsByType = await this.listAllChannelsByType();
+        const channelTypes = Object.keys(channelsByType);
+        const availableStepTypes = _workflow.getAvailableStepTypes(channelTypes);
+        let steps = [];
+        // Stuff with steps
+        if (stepStr) {
+            // Parse steps from flag
+            const [parsedSteps, stepsError] = (0, _generator.parseStepsInput)(stepStr, availableStepTypes);
+            if (stepsError) {
+                return this.error(`Invalid --steps \`${stepStr}\` (${stepsError})`);
+            }
+            steps = parsedSteps || [];
+        } else {
+            // Prompt for steps with multiselect
+            const stepChoices = availableStepTypes.map((stepType)=>({
+                    name: stepType,
+                    message: _generator.StepTagChoices[stepType]
+                }));
+            const stepsResponse = await (0, _enquirer.prompt)({
+                type: "multiselect",
+                name: "steps",
+                message: "(optional) Select step types to bootstrap the workflow with",
+                choices: stepChoices
+            });
+            steps = (stepsResponse === null || stepsResponse === void 0 ? void 0 : stepsResponse.steps) || [];
+        }
+        // 6. Generate the workflow directory with scaffolded steps
+        await _workflow.generateWorkflowDir(workflowDirCtx, {
+            name,
             steps
-        };
-        await _workflow.generateWorkflowDir(dirContext, attrs);
-        this.log(`‣ Successfully generated a workflow directory at ${dirContext.abspath}`);
-        // 5-B. Lastly warn if this workflow already exists in Knock.
-        const isExistingWorkflow = await this.checkExistingWorkflow();
-        if (isExistingWorkflow) {
-            this.log("");
-            this.warn(`Workflow \`${args.workflowKey}\` already exists in \`${flags.environment}\` environment`);
+        }, channelsByType);
+    }
+    async getWorkflowDirContext(workflowKey) {
+        const { resourceDir, cwd: runCwd } = this.runContext;
+        // Inside an existing resource dir, use it if valid for the target workflow.
+        if (resourceDir) {
+            const target = {
+                commandId: _basecommand.default.id,
+                type: "workflow",
+                key: workflowKey
+            };
+            return (0, _runcontext.ensureResourceDirForTarget)(resourceDir, target);
+        }
+        // Default to knock project config first if present, otherwise cwd.
+        const dirCtx = await (0, _projectconfig.resolveResourceDir)(this.projectConfig, "workflow", runCwd);
+        // Not inside any existing workflow directory, which means either create a
+        // new worfklow directory in the cwd, or update it if there is one already.
+        if (workflowKey) {
+            const dirPath = _nodepath.resolve(dirCtx.abspath, workflowKey);
+            const exists = await _workflow.isWorkflowDir(dirPath);
+            return {
+                type: "workflow",
+                key: workflowKey,
+                abspath: dirPath,
+                exists
+            };
         }
+        // Not in any workflow directory, nor a workflow key arg was given so error.
+        return this.error("Missing 1 required arg:\nworkflowKey");
     }
-    async checkExistingWorkflow() {
-        try {
-            const resp = await this.apiV1.getWorkflow(this.props);
-            return resp.status === 200;
-        } catch  {}
+    async listAllChannelsByType() {
+        const channels = await this.apiV1.listAllChannels();
+        // Group channels by type
+        // eslint-disable-next-line unicorn/no-array-reduce
+        const channelsByType = channels.reduce((acc, channel)=>({
+                ...acc,
+                [channel.type]: [
+                    ...acc[channel.type] || [],
+                    channel
+                ]
+            }), {});
+        return channelsByType;
     }
 }
+_define_property(WorkflowNew, "summary", "Create a new workflow with a minimal configuration.");
 _define_property(WorkflowNew, "flags", {
+    name: _core.Flags.string({
+        summary: "The name of the workflow",
+        char: "n"
+    }),
+    key: _core.Flags.string({
+        summary: "The key of the workflow",
+        char: "k"
+    }),
     steps: _core.Flags.string({
-        aliases: [
-            "step"
-        ]
+        summary: "Comma-separated list of step types to include in the workflow",
+        char: "s"
     }),
-    force: _core.Flags.boolean(),
     environment: _core.Flags.string({
-        hidden: true,
+        summary: "The environment to create the workflow in. Defaults to development.",
         default: _const.KnockEnv.Development
+    }),
+    branch: _flag.branch,
+    force: _core.Flags.boolean({
+        summary: "Force the creation of the workflow directory without confirmation."
+    }),
+    push: _core.Flags.boolean({
+        summary: "Whether or not to push the workflow to Knock after creation.",
+        default: false,
+        char: "p"
+    }),
+    template: _core.Flags.string({
+        summary: "The template repository to use for the workflow. Should be `workflows/{type}`. You cannot use this flag with --steps.",
+        char: "t"
     })
 });
-_define_property(WorkflowNew, "args", {
-    workflowKey: _core.Args.string({
-        required: true
-    })
-});
-// TODO(KNO-3072): Unhide after we move the generator logic to the backend.
-_define_property(WorkflowNew, "hidden", true);
+_define_property(WorkflowNew, "args", {});

package/dist/commands/workflow/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 _workflow = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/workflow"));
@@ -132,10 +133,12 @@ class WorkflowPull extends _basecommand.default {
             };
             return (0, _runcontext.ensureResourceDirForTarget)(resourceDir, target);
         }
+        // Default to knock project config first if present, otherwise cwd.
+        const dirCtx = await (0, _projectconfig.resolveResourceDir)(this.projectConfig, "workflow", runCwd);
         // Not inside any existing workflow directory, which means either create a
         // new worfklow directory in the cwd, or update it if there is one already.
         if (workflowKey) {
-            const dirPath = _nodepath.resolve(runCwd, workflowKey);
+            const dirPath = _nodepath.resolve(dirCtx.abspath, workflowKey);
             const exists = await _workflow.isWorkflowDir(dirPath);
             return {
                 type: "workflow",
@@ -151,13 +154,8 @@ class WorkflowPull extends _basecommand.default {
    * Pull all workflows
    */ async pullAllWorkflows() {
         const { flags } = this.props;
-        // TODO: In the future we should default to the knock project config first
-        // if present, before defaulting to the cwd.
-        const defaultToCwd = {
-            abspath: this.runContext.cwd,
-            exists: true
-        };
-        const targetDirCtx = flags["workflows-dir"] || defaultToCwd;
+        const workflowsIndexDirCtx = await (0, _projectconfig.resolveResourceDir)(this.projectConfig, "workflow", this.runContext.cwd);
+        const targetDirCtx = flags["workflows-dir"] || workflowsIndexDirCtx;
         const prompt = targetDirCtx.exists ? `Pull latest workflows into ${targetDirCtx.abspath}?\n  This will overwrite the contents of this directory.` : `Create a new workflows directory at ${targetDirCtx.abspath}?`;
         const input = flags.force || await (0, _ux.promptToConfirm)(prompt);
         if (!input) return;

package/dist/commands/workflow/push.js

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

package/dist/commands/workflow/validate.js

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

package/dist/lib/api-v1.js

@@ -323,6 +323,13 @@ class ApiV1 {
             params
         });
     }
+    async listAllMessageTypes(params) {
+        const messageTypes = [];
+        for await (const messageType of this.mgmtClient.messageTypes.list(params)){
+            messageTypes.push(messageType);
+        }
+        return messageTypes;
+    }
     async getMessageType({ args, flags }) {
         const params = (0, _objectisomorphic.prune)({
             environment: flags.environment,
@@ -425,6 +432,20 @@ class ApiV1 {
             params
         });
     }
+    async listAllChannels() {
+        const channels = [];
+        for await (const channel of this.mgmtClient.channels.list()){
+            channels.push(channel);
+        }
+        return channels;
+    }
+    async listAllEnvironments() {
+        const environments = [];
+        for await (const environment of this.mgmtClient.environments.list()){
+            environments.push(environment);
+        }
+        return environments;
+    }
     // By methods:
     async get(subpath, config) {
         return this.client.get(`/${API_VERSION}` + subpath, config);
@@ -433,18 +454,18 @@ class ApiV1 {
         return this.client.put(`/${API_VERSION}` + subpath, data, config);
     }
     constructor(sessionContext, config){
+        var _ref;
         var _sessionContext_session;
         _define_property(this, "client", void 0);
         _define_property(this, "mgmtClient", void 0);
         const baseURL = sessionContext.apiOrigin;
         const token = this.getToken(sessionContext);
-        var _sessionContext_session_clientId;
         const headers = {
             // Used to authenticate the request to the API.
             Authorization: `Bearer ${token}`,
             // Used in conjunction with the JWT access token, to allow the OAuth server to
             // verify the client ID of the OAuth client that issued the access token.
-            "x-knock-client-id": (_sessionContext_session_clientId = (_sessionContext_session = sessionContext.session) === null || _sessionContext_session === void 0 ? void 0 : _sessionContext_session.clientId) !== null && _sessionContext_session_clientId !== void 0 ? _sessionContext_session_clientId : undefined,
+            "x-knock-client-id": (_ref = (_sessionContext_session = sessionContext.session) === null || _sessionContext_session === void 0 ? void 0 : _sessionContext_session.clientId) !== null && _ref !== void 0 ? _ref : undefined,
             "User-Agent": `${config.userAgent}`
         };
         this.client = _axios.default.create({

package/dist/lib/auth.js

@@ -198,12 +198,12 @@ async function waitForAccessToken(dashboardUrl, authUrl) {
     };
     const browserUrl = `${authorizationEndpoint}?${new URLSearchParams(params).toString()}`;
     server.on("request", async (req, res)=>{
+        var _req_url;
         if (!clientId || !redirectUri) {
             res.writeHead(500).end("Something went wrong");
             cleanupAndReject("something went wrong");
             return;
         }
-        var _req_url;
         const url = new URL((_req_url = req.url) !== null && _req_url !== void 0 ? _req_url : "/", "http://127.0.0.1");
         if (url.pathname !== callbackPath) {
             res.writeHead(404).end("Invalid path");

package/dist/lib/base-command.js

@@ -12,6 +12,7 @@ const _core = require("@oclif/core");
 const _apiv1 = /*#__PURE__*/ _interop_require_default(require("./api-v1"));
 const _auth = /*#__PURE__*/ _interop_require_default(require("./auth"));
 const _accountfeatures = require("./helpers/account-features");
+const _projectconfig = require("./helpers/project-config");
 const _runcontext = /*#__PURE__*/ _interop_require_wildcard(require("./run-context"));
 const _urls = require("./urls");
 const _userconfig = require("./user-config");
@@ -89,52 +90,54 @@ class BaseCommand extends _core.Command {
         this.configStore = new _userconfig.UserConfigStore(this.config.configDir);
         // 1. Load user's config from the config dir, as available.
         await this.configStore.load();
-        // 2. Parse flags and args, must come after the user config load.
+        // 2. Load project config (knock.json) if available.
+        this.projectConfig = await (0, _projectconfig.findAndReadProjectConfig)();
+        // 3. Parse flags and args, must come after the user config load.
         const { args, flags } = await this.parse(this.ctor);
         this.props = {
             args: args,
             flags: flags
         };
-        // 3. Build the initial session context.
+        // 4. Build the initial session context.
         this.sessionContext = this.buildSessionContext();
-        // 4. If the command requires authentication, ensure the session is authenticated.
+        // 5. If the command requires authentication, ensure the session is authenticated.
         if (this.requiresAuth) {
             this.ensureAuthenticated();
         }
-        // 5. If the session context is an OAuth session, refresh the access token.
+        // 6. If the session context is an OAuth session, refresh the access token.
         if (this.sessionContext.type === "oauth") {
             await this.refreshAccessTokenForSession();
         }
-        // 6. Instantiate a knock api client.
+        // 7. Instantiate a knock api client.
         this.apiV1 = new _apiv1.default(this.sessionContext, this.config);
-        // 7. Verify that required features are enabled for the account.
+        // 8. Verify that required features are enabled for the account.
         const ctor = this.ctor;
         if (ctor.verifyFeatureEnabled) {
             await this.verifyFeatureEnabled(ctor.verifyFeatureEnabled);
         }
-        // 8. Load the run context of the invoked command.
+        // 9. Load the run context of the invoked command.
         this.runContext = await _runcontext.load(this.id);
     }
     buildSessionContext() {
+        var _this_props_flags_servicetoken, _this_props_flags_apiorigin;
         const userConfig = this.configStore.get();
         const session = userConfig.userSession;
         // If the user has a session and a service token is not provided, use the session.
         if (session && !this.props.flags["service-token"]) {
-            var _this_props_flags_apiorigin;
+            var _this_props_flags_apiorigin1;
             return sessionWithDefaultOrigins({
                 type: "oauth",
                 session,
-                apiOrigin: (_this_props_flags_apiorigin = this.props.flags["api-origin"]) !== null && _this_props_flags_apiorigin !== void 0 ? _this_props_flags_apiorigin : userConfig.apiOrigin,
+                apiOrigin: (_this_props_flags_apiorigin1 = this.props.flags["api-origin"]) !== null && _this_props_flags_apiorigin1 !== void 0 ? _this_props_flags_apiorigin1 : userConfig.apiOrigin,
                 dashboardOrigin: userConfig.dashboardOrigin,
                 authOrigin: userConfig.authOrigin
             });
         }
-        var _this_props_flags_servicetoken, _this_props_flags_apiorigin1;
         // Otherwise, default to this being a service token session.
         return sessionWithDefaultOrigins({
             type: "service",
             token: (_this_props_flags_servicetoken = this.props.flags["service-token"]) !== null && _this_props_flags_servicetoken !== void 0 ? _this_props_flags_servicetoken : userConfig.serviceToken,
-            apiOrigin: (_this_props_flags_apiorigin1 = this.props.flags["api-origin"]) !== null && _this_props_flags_apiorigin1 !== void 0 ? _this_props_flags_apiorigin1 : userConfig.apiOrigin,
+            apiOrigin: (_this_props_flags_apiorigin = this.props.flags["api-origin"]) !== null && _this_props_flags_apiorigin !== void 0 ? _this_props_flags_apiorigin : userConfig.apiOrigin,
             dashboardOrigin: userConfig.dashboardOrigin,
             authOrigin: userConfig.authOrigin
         });
@@ -156,12 +159,12 @@ class BaseCommand extends _core.Command {
     async refreshAccessTokenForSession() {
         // Maybe refresh the access token?
         try {
+            var _ref, _ref1;
             var _this_sessionContext_session, _this_sessionContext_session1;
-            var _this_sessionContext_session_clientId, _this_sessionContext_session_refreshToken;
             const refreshedSession = await _auth.default.refreshAccessToken({
                 authUrl: this.sessionContext.authOrigin,
-                clientId: (_this_sessionContext_session_clientId = (_this_sessionContext_session = this.sessionContext.session) === null || _this_sessionContext_session === void 0 ? void 0 : _this_sessionContext_session.clientId) !== null && _this_sessionContext_session_clientId !== void 0 ? _this_sessionContext_session_clientId : "",
-                refreshToken: (_this_sessionContext_session_refreshToken = (_this_sessionContext_session1 = this.sessionContext.session) === null || _this_sessionContext_session1 === void 0 ? void 0 : _this_sessionContext_session1.refreshToken) !== null && _this_sessionContext_session_refreshToken !== void 0 ? _this_sessionContext_session_refreshToken : ""
+                clientId: (_ref = (_this_sessionContext_session = this.sessionContext.session) === null || _this_sessionContext_session === void 0 ? void 0 : _this_sessionContext_session.clientId) !== null && _ref !== void 0 ? _ref : "",
+                refreshToken: (_ref1 = (_this_sessionContext_session1 = this.sessionContext.session) === null || _this_sessionContext_session1 === void 0 ? void 0 : _this_sessionContext_session1.refreshToken) !== null && _ref1 !== void 0 ? _ref1 : ""
             });
             this.debug("Successfully refreshed access token.");
             // Update the user config to use the new session.
@@ -178,7 +181,7 @@ class BaseCommand extends _core.Command {
         }
     }
     constructor(...args){
-        super(...args), _define_property(this, "props", void 0), _define_property(this, "apiV1", void 0), _define_property(this, "runContext", void 0), _define_property(this, "sessionContext", void 0), _define_property(this, "configStore", void 0), _define_property(this, "requiresAuth", true);
+        super(...args), _define_property(this, "props", void 0), _define_property(this, "apiV1", void 0), _define_property(this, "runContext", void 0), _define_property(this, "sessionContext", void 0), _define_property(this, "configStore", void 0), _define_property(this, "projectConfig", void 0), _define_property(this, "requiresAuth", true);
     }
 }
 _define_property(BaseCommand, "verifyFeatureEnabled", void 0);

package/dist/lib/helpers/flag.js

@@ -148,8 +148,6 @@ const slug = _core.Flags.custom({
 });
 const branch = slug({
     summary: "The slug of the branch to use.",
-    // TODO Hide until branching is released in GA
-    hidden: true,
     // Memoize this flag's default. oclif runs this default function even when the flag is unused.
     // Using lodash's once avoids unnecessarily reading the branch file multiple times.
     default: (0, _lodash.once)(_branch.readSlugFromBranchFile)