@knocklabs/cli 0.1.0-rc.0 → 0.1.0-rc.1

package/dist/lib/api-v1.js

@@ -17,7 +17,7 @@ function _interopRequireDefault(obj) {
 const DEFAULT_ORIGIN = "https://control.knock.app";
 const API_VERSION = "v1";
 class ApiV1 {
-    // By resources:
+    // By resources: Workflows
     async ping() {
         return this.get("/ping");
     }
@@ -45,7 +45,9 @@ class ApiV1 {
     async upsertWorkflow({ args , flags  }, workflow) {
         const params = (0, _object.prune)({
             environment: flags.environment,
-            annotate: flags.annotate
+            annotate: flags.annotate,
+            commit: flags.commit,
+            commit_message: flags["commit-message"]
         });
         const data = {
             workflow
@@ -54,6 +56,44 @@ class ApiV1 {
             params
         });
     }
+    async validateWorkflow({ args , flags  }, workflow) {
+        const params = (0, _object.prune)({
+            environment: flags.environment
+        });
+        const data = {
+            workflow
+        };
+        return this.put(`/workflows/${args.workflowKey}/validate`, data, {
+            params
+        });
+    }
+    async activateWorkflow({ args , flags  }) {
+        const params = (0, _object.prune)({
+            environment: flags.environment,
+            status: flags.status
+        });
+        return this.put(`/workflows/${args.workflowKey}/activate`, {}, {
+            params
+        });
+    }
+    // By resources: Commits
+    async commitAllChanges({ flags  }) {
+        const params = (0, _object.prune)({
+            environment: flags.environment,
+            commit_message: flags.commit_message
+        });
+        return this.put(`/commits`, {}, {
+            params
+        });
+    }
+    async promoteAllChanges({ flags  }) {
+        const params = (0, _object.prune)({
+            to_environment: flags.to
+        });
+        return this.put(`/commits/promote`, {}, {
+            params
+        });
+    }
     // By methods:
     async get(subpath, config) {
         return this.client.get(`/${API_VERSION}` + subpath, config);

package/dist/lib/base-command.js

@@ -74,7 +74,7 @@ BaseCommand.globalFlags = {
     // - if not provided, fall back to env variable
     // - if not available, fall back to user config
     "service-token": _core.Flags.string({
-        summary: "service token to authenticate with",
+        summary: "The service token to authenticate with",
         required: true,
         multiple: false,
         env: "KNOCK_SERVICE_TOKEN",

package/dist/lib/helpers/{env.js → const.js}

@@ -9,6 +9,7 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    KnockEnv: ()=>KnockEnv,
     isTestEnv: ()=>isTestEnv,
     sandboxDir: ()=>sandboxDir
 });
@@ -59,5 +60,10 @@ function _interopRequireWildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+var KnockEnv;
+(function(KnockEnv) {
+    KnockEnv["Development"] = "development";
+    KnockEnv["Production"] = "production";
+})(KnockEnv || (KnockEnv = {}));
 const isTestEnv = process.env.NODE_ENV === "test";
 const sandboxDir = _nodePath.resolve(_fsExtra.realpathSync(_nodeOs.default.tmpdir()), ".knock");

package/dist/lib/helpers/dir-context.js

@@ -8,18 +8,12 @@ Object.defineProperty(exports, "ensureResourceDirForTarget", {
 });
 const _core = require("@oclif/core");
 const ensureResourceDirForTarget = (resourceDirCtx, target)=>{
-    switch(target.commandId){
-        case "workflow:pull":
-            break;
-        default:
-            throw new Error(`Unhandled commandId: ${target.commandId}`);
-    }
     // If the target resource is a different type than the current resource dir
     // type, error out.
     if (resourceDirCtx.type !== target.type) {
         return _core.CliUx.ux.error(`Cannot run ${target.commandId} inside a ${resourceDirCtx.type} directory`);
     }
-    // If the resource key was not procided with the command, then infer from the
+    // If the resource key was not provided with the command, then infer from the
     // current resource directory context.
     if (!target.key) {
         return resourceDirCtx;

package/dist/lib/helpers/error.js

@@ -10,7 +10,9 @@ function _export(target, all) {
 }
 _export(exports, {
     ApiError: ()=>ApiError,
-    JsonError: ()=>JsonError,
+    JsonSyntaxError: ()=>JsonSyntaxError,
+    JsonDataError: ()=>JsonDataError,
+    LiquidParseError: ()=>LiquidParseError,
     formatErrors: ()=>formatErrors
 });
 const _string = require("./string");
@@ -28,10 +30,18 @@ class CustomError extends Error {
 }
 class ApiError extends CustomError {
 }
-class JsonError extends CustomError {
-    constructor(message, path){
+class JsonSyntaxError extends CustomError {
+}
+class JsonDataError extends CustomError {
+    constructor(message, objPath){
+        super(message);
+        this.objPath = objPath;
+    }
+}
+class LiquidParseError extends CustomError {
+    constructor(message, context){
         super(message);
-        this.path = path;
+        this.context = context;
     }
 }
 /*
@@ -42,12 +52,17 @@ class JsonError extends CustomError {
  */ const formatError = (error)=>{
     switch(true){
         case error instanceof ApiError:
-        case error instanceof SyntaxError:
+        case error instanceof JsonSyntaxError:
             return `${error.name}: ${error.message}`;
-        case error instanceof JsonError:
+        case error instanceof JsonDataError:
+            {
+                const e = error;
+                return e.objPath ? `${e.name}: data at "${e.objPath}" ${e.message}` : `${e.name}: ${e.message}`;
+            }
+        case error instanceof LiquidParseError:
             {
                 const e = error;
-                return e.path === "" ? `${e.name}: ${e.message}` : `${e.name}: data at "${e.path}" ${e.message}`;
+                return `${e.name}: ${e.message + "\n" + e.context}`;
             }
         default:
             throw new Error(`Unhandled error type: ${error}`);

package/dist/lib/helpers/flag.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "booleanStr", {
+    enumerable: true,
+    get: ()=>booleanStr
+});
+const _core = require("@oclif/core");
+const booleanStr = _core.Flags.custom({
+    options: [
+        "true",
+        "false"
+    ],
+    parse: async (input)=>input === "true"
+});

package/dist/lib/helpers/json.js

@@ -14,6 +14,7 @@ _export(exports, {
 });
 const _jsonlint = /*#__PURE__*/ _interopRequireWildcard(require("@prantlf/jsonlint"));
 const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
+const _error = require("./error");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -63,7 +64,7 @@ const readJson = async (filePath)=>{
     } catch (error) {
         // https://github.com/prantlf/jsonlint#error-handling
         if (!(error instanceof SyntaxError)) throw error;
-        errors.push(error);
+        errors.push(new _error.JsonSyntaxError(error.message));
     }
     return [
         payload,

package/dist/lib/helpers/liquid.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "validateLiquidSyntax", {
+    enumerable: true,
+    get: ()=>validateLiquidSyntax
+});
+const _liquidjs = require("liquidjs");
+const _error = require("./error");
+const engine = new _liquidjs.Liquid({
+    timezoneOffset: 0
+});
+// Turn off a couple tags we do not support.
+const disabled = {
+    parse (token) {
+        throw new Error(`"${token.name}" tag is not supported in Knock`);
+    }
+};
+engine.registerTag("render", disabled);
+engine.registerTag("include", disabled);
+function validateLiquidSyntax(input) {
+    try {
+        engine.parse(input);
+        return undefined;
+    } catch (error) {
+        // All liquidjs errors should be extended from the LiquidError class.
+        // Reference: https://liquidjs.com/api/classes/util_error_.liquiderror.html
+        if (!(error instanceof _liquidjs.LiquidError)) throw error;
+        // Here we only care about syntactical errors specifically.
+        switch(true){
+            case error instanceof _liquidjs.TokenizationError:
+            case error instanceof _liquidjs.ParseError:
+                return new _error.LiquidParseError(error.message, error.context);
+            default:
+                return undefined;
+        }
+    }
+}

package/dist/lib/helpers/request.js

@@ -7,8 +7,47 @@ Object.defineProperty(exports, "withSpinner", {
     get: ()=>withSpinner
 });
 const _core = require("@oclif/core");
-const _env = require("./env");
 const _error = require("./error");
+const _spinner = /*#__PURE__*/ _interopRequireWildcard(require("./spinner"));
+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 _interopRequireWildcard(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 = {};
+    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 isSuccessResp = (resp)=>resp.status >= 200 && resp.status < 300;
 /*
  * Returns a formatted error message from an error response based on status code.
@@ -18,7 +57,7 @@ const isSuccessResp = (resp)=>resp.status >= 200 && resp.status < 300;
     }
     const { message , errors =[]  } = data;
     if (status >= 400) {
-        const errs = errors.map((e)=>new _error.JsonError(e.message, e.field));
+        const errs = errors.map((e)=>new _error.JsonDataError(e.message, e.field));
         return errs.length === 0 ? message : message + "\n\n" + (0, _error.formatErrors)(errs);
     }
     return message;
@@ -26,13 +65,13 @@ const isSuccessResp = (resp)=>resp.status >= 200 && resp.status < 300;
 const withSpinner = async (requestFn, opts = {})=>{
     const { action ="‣ Loading" , ensureSuccess =true  } = opts;
     // Suppress printing the spinner in tests, oclif doesn't for some reasons.
-    if (!_env.isTestEnv) _core.CliUx.ux.action.start(action);
+    _spinner.start(action);
     const resp = await requestFn();
     // Error out before the action stop so the spinner can update accordingly.
     if (ensureSuccess && !isSuccessResp(resp)) {
         const message = formatErrorRespMessage(resp);
         _core.CliUx.ux.error(new _error.ApiError(message));
     }
-    _core.CliUx.ux.action.stop();
+    _spinner.stop();
     return resp;
 };

package/dist/lib/helpers/spinner.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    start: ()=>start,
+    stop: ()=>stop
+});
+const _core = require("@oclif/core");
+const _const = require("./const");
+const start = (action)=>{
+    if (!_const.isTestEnv) _core.CliUx.ux.action.start(action);
+};
+const stop = ()=>_core.CliUx.ux.action.stop();

package/dist/lib/helpers/string.js

@@ -1,17 +1,25 @@
 /*
- * Indent each line in a string, useful when printing out nested errors.
- *
- * NOTE: Copied over from https://github.com/sindresorhus/indent-string for now,
- * because getting an "[ERR_REQUIRE_ESM]: Must use import to load ES Module"
- * error when pulling in the package.
+ * Checks if a given string is in a slugified format.
  */ "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "indentString", {
-    enumerable: true,
-    get: ()=>indentString
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    checkSlugifiedFormat: ()=>checkSlugifiedFormat,
+    indentString: ()=>indentString
 });
+const SLUG_FORMAT_RE = /^[\w-]+$/;
+const SLUG_LOWERCASE_FORMAT_RE = /^[\d_a-z-]+$/;
+const checkSlugifiedFormat = (input, opts = {})=>{
+    const { onlyLowerCase =true  } = opts;
+    return onlyLowerCase ? SLUG_LOWERCASE_FORMAT_RE.test(input) : SLUG_FORMAT_RE.test(input);
+};
 const indentString = (string, count = 0, options = {})=>{
     const { indent =" " , includeEmptyLines =false  } = options;
     if (typeof string !== "string") {

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

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    parseStepsInput: ()=>parseStepsInput,
+    generateWorkflowDir: ()=>generateWorkflowDir,
+    scaffoldWorkflowDirBundle: ()=>scaffoldWorkflowDirBundle
+});
+const _lodash = require("lodash");
+const _helpers = require("./helpers");
+const _types = require("./types");
+const _writer = require("./writer");
+const scaffoldDelayStep = (refSuffix)=>{
+    const scaffoldedStep = {
+        ref: `${_types.StepType.Delay}_${refSuffix}`,
+        type: _types.StepType.Delay,
+        settings: {
+            delay_for: {
+                unit: "seconds",
+                value: 30
+            }
+        }
+    };
+    return [
+        scaffoldedStep,
+        {}
+    ];
+};
+const scaffoldBatchStep = (refSuffix)=>{
+    const scaffoldedStep = {
+        ref: `${_types.StepType.Batch}_${refSuffix}`,
+        type: _types.StepType.Batch,
+        settings: {
+            batch_order: "asc",
+            batch_window: {
+                unit: "seconds",
+                value: 30
+            }
+        }
+    };
+    return [
+        scaffoldedStep,
+        {}
+    ];
+};
+const scaffoldHttpFetchStep = (refSuffix)=>{
+    const scaffoldedStep = {
+        ref: `${_types.StepType.HttpFetch}_${refSuffix}`,
+        type: _types.StepType.HttpFetch,
+        settings: {
+            method: "get",
+            url: "https://example.com"
+        }
+    };
+    return [
+        scaffoldedStep,
+        {}
+    ];
+};
+const scaffoldEmailChannelStep = (refSuffix)=>{
+    const stepRef = `email_${refSuffix}`;
+    const templateFilePath = (0, _writer.newTemplateFilePath)(stepRef, "html_body", "html");
+    const scaffoldedStep = {
+        ref: stepRef,
+        type: _types.StepType.Channel,
+        channel_key: "<EMAIL CHANNEL KEY>",
+        template: {
+            settings: {
+                layout_key: "default"
+            },
+            subject: "You've got mail!",
+            ["html_body" + _helpers.FILEPATH_MARKER]: templateFilePath
+        }
+    };
+    const bundleFragment = {
+        [templateFilePath]: "<p>Hello, <strong>{{ recipient.name }}</strong>!</p>"
+    };
+    return [
+        scaffoldedStep,
+        bundleFragment
+    ];
+};
+const scaffoldInAppFeedChannelStep = (refSuffix)=>{
+    const stepRef = `in_app_feed_${refSuffix}`;
+    const templateFilePath = (0, _writer.newTemplateFilePath)(stepRef, "markdown_body", "md");
+    const scaffoldedStep = {
+        ref: stepRef,
+        type: _types.StepType.Channel,
+        channel_key: "<IN-APP-FEED CHANNEL KEY>",
+        template: {
+            action_url: "{{ vars.app_url }}",
+            ["markdown_body" + _helpers.FILEPATH_MARKER]: templateFilePath
+        }
+    };
+    const bundleFragment = {
+        [templateFilePath]: "Hello, **{{ recipient.name }}**!"
+    };
+    return [
+        scaffoldedStep,
+        bundleFragment
+    ];
+};
+const scaffoldSmsChannelStep = (refSuffix)=>{
+    const stepRef = `sms_${refSuffix}`;
+    const templateFilePath = (0, _writer.newTemplateFilePath)(stepRef, "text_body", "txt");
+    const scaffoldedStep = {
+        ref: stepRef,
+        type: _types.StepType.Channel,
+        channel_key: "<SMS CHANNEL KEY>",
+        template: {
+            ["text_body" + _helpers.FILEPATH_MARKER]: templateFilePath
+        }
+    };
+    const bundleFragment = {
+        [templateFilePath]: "Hello, {{ recipient.name }}!"
+    };
+    return [
+        scaffoldedStep,
+        bundleFragment
+    ];
+};
+const scaffoldPushChannelStep = (refSuffix)=>{
+    const stepRef = `push_${refSuffix}`;
+    const templateFilePath = (0, _writer.newTemplateFilePath)(stepRef, "text_body", "txt");
+    const scaffoldedStep = {
+        ref: stepRef,
+        type: _types.StepType.Channel,
+        channel_key: "<PUSH CHANNEL KEY>",
+        template: {
+            settings: {
+                delivery_type: "content"
+            },
+            ["text_body" + _helpers.FILEPATH_MARKER]: templateFilePath
+        }
+    };
+    const bundleFragment = {
+        [templateFilePath]: "Hello, {{ recipient.name }}!"
+    };
+    return [
+        scaffoldedStep,
+        bundleFragment
+    ];
+};
+const scaffoldChatChannelStep = (refSuffix)=>{
+    const stepRef = `chat_${refSuffix}`;
+    const templateFilePath = (0, _writer.newTemplateFilePath)(stepRef, "markdown_body", "md");
+    const scaffoldedStep = {
+        ref: stepRef,
+        type: _types.StepType.Channel,
+        channel_key: "<CHAT CHANNEL KEY>",
+        template: {
+            ["markdown_body" + _helpers.FILEPATH_MARKER]: templateFilePath
+        }
+    };
+    const bundleFragment = {
+        [templateFilePath]: "Hello, **{{ recipient.name }}**!"
+    };
+    return [
+        scaffoldedStep,
+        bundleFragment
+    ];
+};
+const STEP_TAGS = [
+    "delay",
+    "batch",
+    "fetch",
+    "email",
+    "in-app",
+    "sms",
+    "push",
+    "chat"
+];
+const stepScaffoldFuncs = {
+    // Function steps
+    delay: scaffoldDelayStep,
+    batch: scaffoldBatchStep,
+    fetch: scaffoldHttpFetchStep,
+    // Channel steps
+    email: scaffoldEmailChannelStep,
+    "in-app": scaffoldInAppFeedChannelStep,
+    sms: scaffoldSmsChannelStep,
+    push: scaffoldPushChannelStep,
+    chat: scaffoldChatChannelStep
+};
+const parseStepsInput = (input)=>{
+    const tags = input.split(",").filter((x)=>x);
+    const invalidTags = tags.filter((tag)=>!(0, _lodash.get)(stepScaffoldFuncs, tag));
+    if (invalidTags.length > 0) {
+        return [
+            undefined,
+            "must be a comma-separated string of the following values: " + STEP_TAGS.join(", ")
+        ];
+    }
+    return [
+        tags,
+        undefined
+    ];
+};
+const scaffoldWorkflowDirBundle = (attrs)=>{
+    // 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)=>({
+            [tag]: 0
+        })));
+    // 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);
+    }));
+    // Build a workflow directory bundle with scaffolded steps data, plus other
+    // workflow attributes.
+    const workflowJson = {
+        ...attrs,
+        steps: scaffoldedSteps
+    };
+    return (0, _lodash.assign)({
+        [_helpers.WORKFLOW_JSON]: workflowJson
+    }, ...bundleFragments);
+};
+const generateWorkflowDir = async (workflowDirCtx, attrs)=>{
+    const bundle = scaffoldWorkflowDirBundle(attrs);
+    return (0, _writer.writeWorkflowDirFromBundle)(workflowDirCtx, bundle);
+};

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

@@ -12,6 +12,7 @@ _export(exports, {
     WORKFLOW_JSON: ()=>WORKFLOW_JSON,
     FILEPATH_MARKER: ()=>FILEPATH_MARKER,
     FILEPATH_MARKED_RE: ()=>FILEPATH_MARKED_RE,
+    validateWorkflowKey: ()=>validateWorkflowKey,
     lsWorkflowJson: ()=>lsWorkflowJson,
     isWorkflowDir: ()=>isWorkflowDir,
     formatCategories: ()=>formatCategories,
@@ -21,6 +22,7 @@ _export(exports, {
 const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
 const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
 const _lodash = require("lodash");
+const _string = require("../../helpers/string");
 const _types = require("./types");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
@@ -64,6 +66,14 @@ function _interopRequireWildcard(obj, nodeInterop) {
 const WORKFLOW_JSON = "workflow.json";
 const FILEPATH_MARKER = "@";
 const FILEPATH_MARKED_RE = new RegExp(`${FILEPATH_MARKER}$`);
+const validateWorkflowKey = (input)=>{
+    if (!(0, _string.checkSlugifiedFormat)(input, {
+        onlyLowerCase: true
+    })) {
+        return "must include only lowercase alphanumeric, dash, or underscore characters";
+    }
+    return undefined;
+};
 const lsWorkflowJson = async (dirPath)=>{
     const workflowJsonPath = _nodePath.join(dirPath, WORKFLOW_JSON);
     const exists = await _fsExtra.pathExists(workflowJsonPath);

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+_exportStar(require("./generator"), exports);
 _exportStar(require("./helpers"), exports);
 _exportStar(require("./reader"), exports);
 _exportStar(require("./types"), exports);