@knocklabs/cli 0.3.1 → 1.0.0-rc.1

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

@@ -9,9 +9,18 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    get StepTagChoices () {
+        return StepTagChoices;
+    },
     get generateWorkflowDir () {
         return generateWorkflowDir;
     },
+    get generateWorkflowFromTemplate () {
+        return generateWorkflowFromTemplate;
+    },
+    get getAvailableStepTypes () {
+        return getAvailableStepTypes;
+    },
     get parseStepsInput () {
         return parseStepsInput;
     },
@@ -22,7 +31,9 @@ _export(exports, {
 const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
 const _lodash = require("lodash");
 const _constisomorphic = require("../shared/const.isomorphic");
+const _templates = /*#__PURE__*/ _interop_require_wildcard(require("../../templates"));
 const _processorisomorphic = require("./processor.isomorphic");
+const _reader = require("./reader");
 const _types = require("./types");
 const _writer = require("./writer");
 function _getRequireWildcardCache(nodeInterop) {
@@ -115,13 +126,14 @@ const scaffoldHttpFetchStep = (refSuffix)=>{
         {}
     ];
 };
-const scaffoldEmailChannelStep = (refSuffix)=>{
+const scaffoldEmailChannelStep = (refSuffix, channels)=>{
     const stepRef = `email_${refSuffix}`;
     const templateFilePath = newTemplateFilePath(stepRef, "html_body", "html");
+    const firstChannel = channels[0];
     const scaffoldedStep = {
         ref: stepRef,
         type: _types.StepType.Channel,
-        channel_key: "<EMAIL CHANNEL KEY>",
+        channel_key: firstChannel ? firstChannel.key : "<EMAIL CHANNEL KEY>",
         template: {
             settings: {
                 layout_key: "default"
@@ -138,13 +150,14 @@ const scaffoldEmailChannelStep = (refSuffix)=>{
         bundleFragment
     ];
 };
-const scaffoldInAppFeedChannelStep = (refSuffix)=>{
+const scaffoldInAppFeedChannelStep = (refSuffix, channels)=>{
     const stepRef = `in_app_feed_${refSuffix}`;
     const templateFilePath = newTemplateFilePath(stepRef, "markdown_body", "md");
+    const firstChannel = channels[0];
     const scaffoldedStep = {
         ref: stepRef,
         type: _types.StepType.Channel,
-        channel_key: "<IN-APP-FEED CHANNEL KEY>",
+        channel_key: firstChannel ? firstChannel.key : "<IN-APP-FEED CHANNEL KEY>",
         template: {
             action_url: "{{ vars.app_url }}",
             ["markdown_body" + _constisomorphic.FILEPATH_MARKER]: templateFilePath
@@ -158,13 +171,14 @@ const scaffoldInAppFeedChannelStep = (refSuffix)=>{
         bundleFragment
     ];
 };
-const scaffoldSmsChannelStep = (refSuffix)=>{
+const scaffoldSmsChannelStep = (refSuffix, channels)=>{
     const stepRef = `sms_${refSuffix}`;
     const templateFilePath = newTemplateFilePath(stepRef, "text_body", "txt");
+    const firstChannel = channels[0];
     const scaffoldedStep = {
         ref: stepRef,
         type: _types.StepType.Channel,
-        channel_key: "<SMS CHANNEL KEY>",
+        channel_key: firstChannel ? firstChannel.key : "<SMS CHANNEL KEY>",
         template: {
             ["text_body" + _constisomorphic.FILEPATH_MARKER]: templateFilePath
         }
@@ -177,13 +191,14 @@ const scaffoldSmsChannelStep = (refSuffix)=>{
         bundleFragment
     ];
 };
-const scaffoldPushChannelStep = (refSuffix)=>{
+const scaffoldPushChannelStep = (refSuffix, channels)=>{
     const stepRef = `push_${refSuffix}`;
     const templateFilePath = newTemplateFilePath(stepRef, "text_body", "txt");
+    const firstChannel = channels[0];
     const scaffoldedStep = {
         ref: stepRef,
         type: _types.StepType.Channel,
-        channel_key: "<PUSH CHANNEL KEY>",
+        channel_key: firstChannel ? firstChannel.key : "<PUSH CHANNEL KEY>",
         template: {
             settings: {
                 delivery_type: "content"
@@ -199,13 +214,14 @@ const scaffoldPushChannelStep = (refSuffix)=>{
         bundleFragment
     ];
 };
-const scaffoldChatChannelStep = (refSuffix)=>{
+const scaffoldChatChannelStep = (refSuffix, channels)=>{
     const stepRef = `chat_${refSuffix}`;
     const templateFilePath = newTemplateFilePath(stepRef, "markdown_body", "md");
+    const firstChannel = channels[0];
     const scaffoldedStep = {
         ref: stepRef,
         type: _types.StepType.Channel,
-        channel_key: "<CHAT CHANNEL KEY>",
+        channel_key: firstChannel ? firstChannel.key : "<CHAT CHANNEL KEY>",
         template: {
             ["markdown_body" + _constisomorphic.FILEPATH_MARKER]: templateFilePath
         }
@@ -223,11 +239,21 @@ const STEP_TAGS = [
     "batch",
     "fetch",
     "email",
-    "in-app",
+    "in-app-feed",
     "sms",
     "push",
     "chat"
 ];
+const StepTagChoices = {
+    delay: "Delay step",
+    batch: "Batch step",
+    fetch: "HTTP Fetch step",
+    email: "Email channel step",
+    "in-app-feed": "In-app feed channel step",
+    sms: "SMS channel step",
+    push: "Push channel step",
+    chat: "Chat channel step"
+};
 const stepScaffoldFuncs = {
     // Function steps
     delay: scaffoldDelayStep,
@@ -235,18 +261,18 @@ const stepScaffoldFuncs = {
     fetch: scaffoldHttpFetchStep,
     // Channel steps
     email: scaffoldEmailChannelStep,
-    "in-app": scaffoldInAppFeedChannelStep,
+    "in-app-feed": scaffoldInAppFeedChannelStep,
     sms: scaffoldSmsChannelStep,
     push: scaffoldPushChannelStep,
     chat: scaffoldChatChannelStep
 };
-const parseStepsInput = (input)=>{
+const parseStepsInput = (input, availableStepTypes)=>{
     const tags = input.split(",").filter((x)=>x);
-    const invalidTags = tags.filter((tag)=>!(0, _lodash.get)(stepScaffoldFuncs, tag));
+    const invalidTags = tags.filter((tag)=>!availableStepTypes.includes(tag));
     if (invalidTags.length > 0) {
         return [
             undefined,
-            "must be a comma-separated string of the following values: " + STEP_TAGS.join(", ")
+            `Invalid step type: ${invalidTags.join(", ")}`
         ];
     }
     return [
@@ -254,7 +280,26 @@ const parseStepsInput = (input)=>{
         undefined
     ];
 };
-const scaffoldWorkflowDirBundle = (attrs)=>{
+const getAvailableStepTypes = (channelTypes)=>{
+    // Return a list of step
+    return STEP_TAGS.filter((stepTag)=>{
+        switch(stepTag){
+            case "email":
+                return channelTypes.includes("email");
+            case "in-app-feed":
+                return channelTypes.includes("in_app_feed");
+            case "sms":
+                return channelTypes.includes("sms");
+            case "push":
+                return channelTypes.includes("push");
+            case "chat":
+                return channelTypes.includes("chat");
+            default:
+                return true;
+        }
+    });
+};
+const scaffoldWorkflowDirBundle = (attrs, channelsByType)=>{
     // A map of 1-based counters to track the number of each step tag seen, used
     // for formatting step refs.
     const stepCountByTag = (0, _lodash.assign)({}, ...STEP_TAGS.map((tag)=>({
@@ -263,7 +308,17 @@ const scaffoldWorkflowDirBundle = (attrs)=>{
     // Scaffold workflow steps data based on given step tags.
     const [scaffoldedSteps = [], bundleFragments = []] = (0, _lodash.zip)(...(attrs.steps || []).map((tag)=>{
         const stepCount = ++stepCountByTag[tag];
-        return stepScaffoldFuncs[tag](stepCount);
+        switch(tag){
+            case "email":
+            case "sms":
+            case "push":
+            case "chat":
+                return stepScaffoldFuncs[tag](stepCount, (0, _lodash.get)(channelsByType, tag, []));
+            case "in-app-feed":
+                return stepScaffoldFuncs[tag](stepCount, (0, _lodash.get)(channelsByType, "in_app_feed", []));
+            default:
+                return stepScaffoldFuncs[tag](stepCount);
+        }
     }));
     // Build a workflow directory bundle with scaffolded steps data, plus other
     // workflow attributes.
@@ -275,7 +330,108 @@ const scaffoldWorkflowDirBundle = (attrs)=>{
         [_processorisomorphic.WORKFLOW_JSON]: workflowJson
     }, ...bundleFragments);
 };
-const generateWorkflowDir = async (workflowDirCtx, attrs)=>{
-    const bundle = scaffoldWorkflowDirBundle(attrs);
+const generateWorkflowDir = async (workflowDirCtx, attrs, channelsByType)=>{
+    const bundle = scaffoldWorkflowDirBundle(attrs, channelsByType);
     return (0, _writer.writeWorkflowDirFromBundle)(workflowDirCtx, bundle);
 };
+function swapChannelReferences(step, channelsByType) {
+    // Temporary until we start shipping the `channel_type` field on channel steps
+    // so that we can then branch by that value.
+    switch(step.channel_key){
+        case "postmark":
+        case "sendgrid":
+        case "resend":
+        case "email":
+        case "knock-email":
+            var _channelsByType_email_;
+            return {
+                ...step,
+                channel_key: (_channelsByType_email_ = channelsByType.email[0]) === null || _channelsByType_email_ === void 0 ? void 0 : _channelsByType_email_.key
+            };
+        case "in-app-feed":
+        case "knock-in-app-feed":
+        case "knock-feed":
+            var _channelsByType_in_app_feed_;
+            return {
+                ...step,
+                channel_key: (_channelsByType_in_app_feed_ = channelsByType.in_app_feed[0]) === null || _channelsByType_in_app_feed_ === void 0 ? void 0 : _channelsByType_in_app_feed_.key
+            };
+        case "sms":
+        case "knock-sms":
+        case "twilio":
+            var _channelsByType_sms_;
+            return {
+                ...step,
+                channel_key: (_channelsByType_sms_ = channelsByType.sms[0]) === null || _channelsByType_sms_ === void 0 ? void 0 : _channelsByType_sms_.key
+            };
+        case "push":
+        case "apns":
+        case "fcm":
+            var _channelsByType_push_;
+            return {
+                ...step,
+                channel_key: (_channelsByType_push_ = channelsByType.push[0]) === null || _channelsByType_push_ === void 0 ? void 0 : _channelsByType_push_.key
+            };
+        case "chat":
+            var _channelsByType_chat_;
+            return {
+                ...step,
+                channel_key: (_channelsByType_chat_ = channelsByType.chat[0]) === null || _channelsByType_chat_ === void 0 ? void 0 : _channelsByType_chat_.key
+            };
+        default:
+            throw new Error(`Unknown channel type: ${step.channel_key}`);
+    }
+}
+function walkWorkflowSteps(steps, channelsByType) {
+    return steps.map((step)=>{
+        switch(step.type){
+            case _types.StepType.Channel:
+                return swapChannelReferences(step, channelsByType);
+            case _types.StepType.Branch:
+                var _step_branches;
+                return {
+                    ...step,
+                    branches: ((_step_branches = step.branches) !== null && _step_branches !== void 0 ? _step_branches : []).map((branch)=>{
+                        var _branch_steps;
+                        return {
+                            ...branch,
+                            steps: walkWorkflowSteps((_branch_steps = branch.steps) !== null && _branch_steps !== void 0 ? _branch_steps : [], channelsByType)
+                        };
+                    })
+                };
+            default:
+                return step;
+        }
+    });
+}
+const generateWorkflowFromTemplate = async (workflowDirCtx, templateString, attrs, channelsByType)=>{
+    let tempDir;
+    try {
+        var _workflow_steps;
+        // Download the template directory into a temp directory
+        tempDir = await _templates.downloadTemplate(templateString);
+        // Create a workflow directory context for the temp directory
+        const tempWorkflowDirCtx = {
+            type: "workflow",
+            key: "temp",
+            abspath: tempDir,
+            exists: true
+        };
+        // Read the workflow.json from the temp directory we downloaded
+        const [workflow, errors] = await (0, _reader.readWorkflowDir)(tempWorkflowDirCtx, {
+            withExtractedFiles: true
+        });
+        if (errors.length > 0 || !workflow) {
+            throw new Error(`Invalid workflow template: ${errors.join(", ")}`);
+        }
+        // Modify the workflow data with the new attributes
+        workflow.name = attrs.name;
+        // Parse the workflow steps, and replace any channel steps with the correct `channel_key`
+        workflow.steps = walkWorkflowSteps((_workflow_steps = workflow.steps) !== null && _workflow_steps !== void 0 ? _workflow_steps : [], channelsByType);
+        // Finally, we write the workflow into the target workflow directory
+        (0, _writer.writeWorkflowDirFromData)(workflowDirCtx, workflow);
+        return;
+    } finally{
+        await _templates.cleanupTempDir(tempDir);
+    }
+};

package/dist/lib/marshal/workflow/helpers.js

@@ -45,6 +45,7 @@ const _core = require("@oclif/core");
 const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
 const _lodash = require("lodash");
 const _quicktypecore = require("quicktype-core");
+const _projectconfig = require("../../helpers/project-config");
 const _string = require("../../helpers/string");
 const _typegen = require("../../helpers/typegen");
 const _processorisomorphic = require("./processor.isomorphic");
@@ -197,7 +198,7 @@ const formatStepSummary = (step)=>{
 const formatStatus = (workflow)=>{
     return workflow.active ? "active" : "inactive";
 };
-const ensureValidCommandTarget = async (props, runContext)=>{
+const ensureValidCommandTarget = async (props, runContext, projectConfig)=>{
     const { args, flags } = props;
     const { commandId, resourceDir: resourceDirCtx, cwd: runCwd } = runContext;
     // If the target resource is a different type than the current resource dir
@@ -209,6 +210,9 @@ const ensureValidCommandTarget = async (props, runContext)=>{
     if (flags.all && args.workflowKey) {
         return _core.ux.error(`workflowKey arg \`${args.workflowKey}\` cannot also be provided when using --all`);
     }
+    // Targeting all workflow dirs in the workflows index dir.
+    // Default to knock project config first if present, otherwise cwd.
+    const workflowsIndexDirCtx = await (0, _projectconfig.resolveResourceDir)(projectConfig, "workflow", runCwd);
     // --all flag is given, which means no workflow key arg.
     if (flags.all) {
         // If --all flag used inside a workflow directory, then require a workflows
@@ -216,16 +220,9 @@ const ensureValidCommandTarget = async (props, runContext)=>{
         if (resourceDirCtx && !flags["workflows-dir"]) {
             return _core.ux.error("Missing required flag workflows-dir");
         }
-        // Targeting all workflow dirs in the workflows index dir.
-        // TODO: Default to the knock project config first if present before cwd.
-        const defaultToCwd = {
-            abspath: runCwd,
-            exists: true
-        };
-        const indexDirCtx = flags["workflows-dir"] || defaultToCwd;
         return {
             type: "workflowsIndexDir",
-            context: indexDirCtx
+            context: flags["workflows-dir"] || workflowsIndexDirCtx
         };
     }
     // Workflow key arg is given, which means no --all flag.
@@ -233,7 +230,7 @@ const ensureValidCommandTarget = async (props, runContext)=>{
         if (resourceDirCtx && resourceDirCtx.key !== args.workflowKey) {
             return _core.ux.error(`Cannot run ${commandId} \`${args.workflowKey}\` inside another workflow directory:\n${resourceDirCtx.key}`);
         }
-        const targetDirPath = resourceDirCtx ? resourceDirCtx.abspath : _nodepath.resolve(runCwd, args.workflowKey);
+        const targetDirPath = resourceDirCtx ? resourceDirCtx.abspath : _nodepath.resolve(workflowsIndexDirCtx.abspath, args.workflowKey);
         const workflowDirCtx = {
             type: "workflow",
             key: args.workflowKey,

package/dist/lib/run-context/loader.js

@@ -14,6 +14,7 @@ Object.defineProperty(exports, "load", {
 });
 const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
 const _emaillayout = /*#__PURE__*/ _interop_require_wildcard(require("../marshal/email-layout"));
+const _guide = /*#__PURE__*/ _interop_require_wildcard(require("../marshal/guide"));
 const _messagetype = /*#__PURE__*/ _interop_require_wildcard(require("../marshal/message-type"));
 const _partial = /*#__PURE__*/ _interop_require_wildcard(require("../marshal/partial"));
 const _translation = /*#__PURE__*/ _interop_require_wildcard(require("../marshal/translation"));
@@ -74,6 +75,10 @@ const evaluateRecursively = async (ctx, currDir)=>{
         if (isWorkflowDir) {
             ctx.resourceDir = buildResourceDirContext("workflow", currDir);
         }
+        const isGuideDir = await _guide.isGuideDir(currDir);
+        if (isGuideDir) {
+            ctx.resourceDir = buildResourceDirContext("guide", currDir);
+        }
         const isEmailLayoutDir = await _emaillayout.isEmailLayoutDir(currDir);
         if (isEmailLayoutDir) {
             ctx.resourceDir = buildResourceDirContext("email_layout", currDir);

package/dist/lib/templates.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get cleanupTempDir () {
+        return cleanupTempDir;
+    },
+    get downloadTemplate () {
+        return downloadTemplate;
+    },
+    get resolveTemplate () {
+        return resolveTemplate;
+    }
+});
+const _nodeos = /*#__PURE__*/ _interop_require_wildcard(require("node:os"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _degit = /*#__PURE__*/ _interop_require_default(require("degit"));
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+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 DEFAULT_ORG = "knocklabs";
+const DEFAULT_REPO = "templates";
+const TEMP_DIR_PREFIX = "knock-cli-templates";
+function resolveTemplate(templateString) {
+    const parts = templateString.split("/");
+    let org;
+    let repo;
+    let subdir;
+    if (parts.length === 2) {
+        // workflows/some-workflow
+        org = DEFAULT_ORG;
+        repo = DEFAULT_REPO;
+        subdir = parts.join("/");
+    }
+    if (parts.length === 4) {
+        // knocklabs/templates/workflows/some-workflow
+        org = parts[0];
+        repo = parts[1];
+        subdir = parts.slice(2).join("/");
+    }
+    if (!org || !repo || !subdir) {
+        throw new Error(`Invalid template string: ${templateString}. Expected format: org/repo/subdir`);
+    }
+    return {
+        org,
+        repo,
+        subdir
+    };
+}
+function buildSource(org, repo, subdir, branch = "main") {
+    const base = `${org}/${repo}`;
+    if (subdir) {
+        return `${base}/${subdir}#${branch}`;
+    }
+    return `${base}#${branch}`;
+}
+async function downloadTemplate(templateString) {
+    const { org, repo, subdir } = resolveTemplate(templateString);
+    const source = buildSource(org, repo, subdir);
+    // Create temp directory for template
+    const tempDir = _nodepath.default.join(_nodeos.tmpdir(), TEMP_DIR_PREFIX, `${org}-${repo}-${subdir.replace(/\//g, "-")}-${Date.now()}`);
+    await _fsextra.ensureDir(tempDir);
+    try {
+        const emitter = (0, _degit.default)(source, {
+            cache: false,
+            force: true,
+            verbose: false
+        });
+        await emitter.clone(tempDir);
+        return tempDir;
+    } catch (error) {
+        await _fsextra.remove(tempDir);
+        throw new Error(`Failed to download template: ${error instanceof Error ? error.message : "Unknown error"}\n\nSource: ${source}`);
+    }
+}
+async function cleanupTempDir(tempDir) {
+    if (tempDir && tempDir.includes(TEMP_DIR_PREFIX)) {
+        await _fsextra.remove(tempDir);
+    }
+}