@knocklabs/cli 0.1.0-rc.0

package/dist/lib/helpers/error.js

@@ -0,0 +1,60 @@
+"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, {
+    ApiError: ()=>ApiError,
+    JsonError: ()=>JsonError,
+    formatErrors: ()=>formatErrors
+});
+const _string = require("./string");
+// Extends the built-in Error class while maintaining a prototype chain, to
+// provide a base class for creating custom error classes.
+// Reference: https://stackoverflow.com/a/58417721/3479934
+class CustomError extends Error {
+    constructor(message){
+        // Error breaks the prototype chain here.
+        super(message);
+        // Restore the prototype chain.
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = new.target.name;
+    }
+}
+class ApiError extends CustomError {
+}
+class JsonError extends CustomError {
+    constructor(message, path){
+        super(message);
+        this.path = path;
+    }
+}
+/*
+ * Returns a formatted error message string from a single error instance.
+ *
+ * Note, primarily used to print out multiple errors below. When only need to
+ * surface a single error, the oclif error helper takes an error instance.
+ */ const formatError = (error)=>{
+    switch(true){
+        case error instanceof ApiError:
+        case error instanceof SyntaxError:
+            return `${error.name}: ${error.message}`;
+        case error instanceof JsonError:
+            {
+                const e = error;
+                return e.path === "" ? `${e.name}: ${e.message}` : `${e.name}: data at "${e.path}" ${e.message}`;
+            }
+        default:
+            throw new Error(`Unhandled error type: ${error}`);
+    }
+};
+const formatErrors = (errors, opts = {})=>{
+    const { joinBy ="\n\n" , indentBy =0  } = opts;
+    const formatted = errors.map((e)=>formatError(e)).join(joinBy);
+    return (0, _string.indentString)(formatted, indentBy);
+};

package/dist/lib/helpers/json.js

@@ -0,0 +1,72 @@
+"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, {
+    DOUBLE_SPACES: ()=>DOUBLE_SPACES,
+    readJson: ()=>readJson
+});
+const _jsonlint = /*#__PURE__*/ _interopRequireWildcard(require("@prantlf/jsonlint"));
+const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
+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 DOUBLE_SPACES = "  ";
+const readJson = async (filePath)=>{
+    const json = await _fsExtra.readFile(filePath, "utf8");
+    let payload;
+    const errors = [];
+    try {
+        payload = _jsonlint.parse(json);
+    } catch (error) {
+        // https://github.com/prantlf/jsonlint#error-handling
+        if (!(error instanceof SyntaxError)) throw error;
+        errors.push(error);
+    }
+    return [
+        payload,
+        errors
+    ];
+};

package/dist/lib/helpers/object.js

@@ -0,0 +1,111 @@
+"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, {
+    split: ()=>split,
+    omitDeep: ()=>omitDeep,
+    prune: ()=>prune,
+    merge: ()=>merge,
+    ObjPath: ()=>ObjPath
+});
+const _lodash = require("lodash");
+const split = (obj, paths)=>{
+    const picked = (0, _lodash.pick)(obj, paths);
+    const remainder = (0, _lodash.omit)(obj, paths);
+    return [
+        picked,
+        remainder
+    ];
+};
+const omitDeep = (input, paths)=>{
+    const omitDeepOnOwnProps = (item)=>{
+        if (Array.isArray(item)) {
+            return item.map((i)=>omitDeepOnOwnProps(i));
+        }
+        if ((0, _lodash.isPlainObject)(item)) {
+            const obj = (0, _lodash.omit)(item, paths);
+            for (const [k, v] of Object.entries(obj)){
+                obj[k] = omitDeep(v, paths);
+            }
+            return obj;
+        }
+        return item;
+    };
+    return Array.isArray(input) ? input.map((i)=>omitDeepOnOwnProps(i)) : omitDeepOnOwnProps(input);
+};
+const prune = (obj)=>(0, _lodash.omitBy)(obj, _lodash.isNil);
+const merge = (obj, ...sources)=>(0, _lodash.merge)({}, obj, ...sources);
+class ObjPath {
+    // Pushes a new path part to its inner state, moving down into an obj tree.
+    push(part) {
+        this.parts = [
+            ...this.parts,
+            part
+        ];
+        return this;
+    }
+    // Pops the last path part from its inner state, moving up in an obj tree.
+    pop() {
+        this.parts = this.parts.slice(0, -1);
+        return this;
+    }
+    // Resets its inner parts state to the given path parts.
+    reset(parts) {
+        this.parts = [
+            ...parts
+        ];
+        return this;
+    }
+    // Returns the current state in a NEW array, mainly used to bookmark a certain
+    // point in the path so we can reset to.
+    checkout() {
+        return [
+            ...this.parts
+        ];
+    }
+    // Takes one or multiple path parts, then returns a single purpose object with
+    // a `str` lambda method that's hardcoded to format a path string based on the
+    // latest parts state plus given parts. Useful when formatting a path string
+    // looking ahead without pushing/popping.
+    to(forward) {
+        const temp = Array.isArray(forward) ? forward : [
+            forward
+        ];
+        const parts = [
+            ...this.parts,
+            ...temp
+        ];
+        return {
+            get str () {
+                return ObjPath.stringify(parts);
+            }
+        };
+    }
+    // Getter method that calls stringify on its current path parts state, to
+    // return the formatted object path.
+    get str() {
+        return ObjPath.stringify(this.parts);
+    }
+    // Takes an array of path parts, then returns a json path notation string,
+    // useful in displaying a helpful reference to users in error messages as well
+    // as reading/updating objects (e.g. via the lodash get or set method).
+    static stringify(parts) {
+        return parts.map((part, idx)=>{
+            if (typeof part === "string") return idx === 0 ? part : `.${part}`;
+            if (typeof part === "number") return `[${part}]`;
+            throw new Error(`Unhandled path part type: ${part}`);
+        }).join("");
+    }
+    constructor(parts = []){
+        this.parts = [
+            ...parts
+        ];
+    }
+}

package/dist/lib/helpers/page.js

@@ -0,0 +1,92 @@
+"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, {
+    PageAction: ()=>PageAction,
+    pageFlags: ()=>pageFlags,
+    toPageParams: ()=>toPageParams,
+    maybePromptPageAction: ()=>maybePromptPageAction,
+    paramsForPageAction: ()=>paramsForPageAction,
+    formatPageActionPrompt: ()=>formatPageActionPrompt,
+    validatePageActionInput: ()=>validatePageActionInput
+});
+const _core = require("@oclif/core");
+const _enquirer = /*#__PURE__*/ _interopRequireDefault(require("enquirer"));
+const _lodash = require("lodash");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const pageFlags = {
+    after: _core.Flags.string(),
+    before: _core.Flags.string(),
+    limit: _core.Flags.integer({
+        max: 100
+    })
+};
+const toPageParams = (flags)=>{
+    return (0, _lodash.pick)(flags, Object.keys(pageFlags));
+};
+var PageAction;
+(function(PageAction) {
+    PageAction["Previous"] = "p";
+    PageAction["Next"] = "n";
+})(PageAction || (PageAction = {}));
+/*
+ * Format a prompt text to show available page actions.
+ * e.g. [p: preview, n: next]
+ */ const formatPageActionPrompt = (pageInfo)=>{
+    const options = [
+        pageInfo.before && `${PageAction.Previous}: previous page`,
+        pageInfo.after && `${PageAction.Next}: next page`
+    ].filter((x)=>x);
+    return options.length > 0 ? `[${options.join(", ")}]` : undefined;
+};
+/*
+ * Validate a prompt input for a page action based on available options and
+ * return if valid.
+ */ const validatePageActionInput = (input, pageInfo)=>{
+    const val = input.toLowerCase().trim();
+    if (pageInfo.after && val === PageAction.Next) {
+        return PageAction.Next;
+    }
+    if (pageInfo.before && val === PageAction.Previous) {
+        return PageAction.Previous;
+    }
+};
+const maybePromptPageAction = async (pageInfo)=>{
+    const message = formatPageActionPrompt(pageInfo);
+    if (!message) return;
+    try {
+        const answer = await _enquirer.default.prompt({
+            type: "input",
+            name: "input",
+            message
+        });
+        return validatePageActionInput(answer.input, pageInfo);
+    } catch (error) {
+        console.log(error);
+        return undefined;
+    }
+};
+const paramsForPageAction = (pageAction, pageInfo)=>{
+    switch(pageAction){
+        case PageAction.Previous:
+            return {
+                before: pageInfo.before
+            };
+        case PageAction.Next:
+            return {
+                after: pageInfo.after
+            };
+        default:
+    }
+};

package/dist/lib/helpers/request.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "withSpinner", {
+    enumerable: true,
+    get: ()=>withSpinner
+});
+const _core = require("@oclif/core");
+const _env = require("./env");
+const _error = require("./error");
+const isSuccessResp = (resp)=>resp.status >= 200 && resp.status < 300;
+/*
+ * Returns a formatted error message from an error response based on status code.
+ */ const formatErrorRespMessage = ({ status , data  })=>{
+    if (status === 500) {
+        return "An internal server error occurred";
+    }
+    const { message , errors =[]  } = data;
+    if (status >= 400) {
+        const errs = errors.map((e)=>new _error.JsonError(e.message, e.field));
+        return errs.length === 0 ? message : message + "\n\n" + (0, _error.formatErrors)(errs);
+    }
+    return message;
+};
+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);
+    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();
+    return resp;
+};

package/dist/lib/helpers/string.js

@@ -0,0 +1,34 @@
+/*
+ * 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.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "indentString", {
+    enumerable: true,
+    get: ()=>indentString
+});
+const indentString = (string, count = 0, options = {})=>{
+    const { indent =" " , includeEmptyLines =false  } = options;
+    if (typeof string !== "string") {
+        throw new TypeError(`Expected \`input\` to be a \`string\`, got \`${typeof string}\``);
+    }
+    if (typeof count !== "number") {
+        throw new TypeError(`Expected \`count\` to be a \`number\`, got \`${typeof count}\``);
+    }
+    if (count < 0) {
+        throw new RangeError(`Expected \`count\` to be at least 0, got \`${count}\``);
+    }
+    if (typeof indent !== "string") {
+        throw new TypeError(`Expected \`options.indent\` to be a \`string\`, got \`${typeof indent}\``);
+    }
+    if (count === 0) {
+        return string;
+    }
+    const regex = includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
+    return string.replace(regex, indent.repeat(count));
+};

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "formatConditions", {
+    enumerable: true,
+    get: ()=>formatConditions
+});
+const formatConditionsList = (conditions, joinedBy, appendedBy = "")=>conditions.map((c)=>`"${c.variable}" ${c.operator} "${c.argument}"`).join(`; ${joinedBy.toUpperCase()}\n`) + appendedBy;
+const formatNestedConditions = (nestedConds, joinedBy, appendedBy = "")=>nestedConds.map(({ any , all  })=>{
+        if (any) return formatConditionsList(any, "or");
+        if (all) return formatConditionsList(all, "and");
+        throw new Error(`Invalid nested conditions: ${nestedConds}`);
+    }).join(`\n ${joinedBy.toUpperCase()}\n`) + appendedBy;
+const formatConditions = (conditions)=>{
+    const { any , all  } = conditions;
+    if (any) {
+        const [condition] = any;
+        return "variable" in condition ? formatConditionsList(any, "or", "\n") : formatNestedConditions(any, "or", "\n");
+    }
+    if (all) {
+        const [condition] = all;
+        return "variable" in condition ? formatConditionsList(all, "and", "\n") : formatNestedConditions(all, "and", "\n");
+    }
+    throw new Error(`Invalid conditions: ${conditions}`);
+};

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_exportStar(require("./helpers"), exports);
+_exportStar(require("./types"), exports);
+function _exportStar(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) Object.defineProperty(to, k, {
+            enumerable: true,
+            get: function() {
+                return from[k];
+            }
+        });
+    });
+    return from;
+}

package/dist/lib/marshal/conditions/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/dist/lib/marshal/shared/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

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

@@ -0,0 +1,139 @@
+"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, {
+    WORKFLOW_JSON: ()=>WORKFLOW_JSON,
+    FILEPATH_MARKER: ()=>FILEPATH_MARKER,
+    FILEPATH_MARKED_RE: ()=>FILEPATH_MARKED_RE,
+    lsWorkflowJson: ()=>lsWorkflowJson,
+    isWorkflowDir: ()=>isWorkflowDir,
+    formatCategories: ()=>formatCategories,
+    formatStepSummary: ()=>formatStepSummary,
+    formatStatus: ()=>formatStatus
+});
+const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
+const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
+const _lodash = require("lodash");
+const _types = require("./types");
+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 WORKFLOW_JSON = "workflow.json";
+const FILEPATH_MARKER = "@";
+const FILEPATH_MARKED_RE = new RegExp(`${FILEPATH_MARKER}$`);
+const lsWorkflowJson = async (dirPath)=>{
+    const workflowJsonPath = _nodePath.join(dirPath, WORKFLOW_JSON);
+    const exists = await _fsExtra.pathExists(workflowJsonPath);
+    return exists ? workflowJsonPath : undefined;
+};
+const isWorkflowDir = async (dirPath)=>Boolean(await lsWorkflowJson(dirPath));
+const formatCategories = (workflow, opts = {})=>{
+    const { categories  } = workflow;
+    const { truncateAfter: limit , emptyDisplay =""  } = opts;
+    if (!categories) return emptyDisplay;
+    const count = categories.length;
+    if (!limit || limit >= count) return categories.join(", ");
+    return (0, _lodash.take)(categories, limit).join(", ") + ` (+ ${count - limit} more)`;
+};
+/*
+ * Returns a formatted string of workflow steps.
+ */ const channelStepSummaryLines = (step)=>{
+    if (step.type !== _types.StepType.Channel) return [];
+    const { channel_key , channel_group_key  } = step;
+    return [
+        channel_key && `Channel: ${channel_key}`,
+        channel_group_key && `Channel group: ${channel_group_key}`
+    ].filter((x)=>x);
+};
+const batchStepSummaryLines = (step)=>{
+    if (step.type !== _types.StepType.Batch) return [];
+    const { batch_key , batch_window: duration , batch_until_field_path: field_path , batch_order  } = step.settings;
+    return [
+        batch_key && `Batch key: ${batch_key}`,
+        duration && `Batch window: ${duration.value} ${duration.unit}`,
+        field_path && `Batch window: "${field_path}"`,
+        `Batch order: ${batch_order}`
+    ];
+};
+const delayStepSummaryLines = (step)=>{
+    if (step.type !== _types.StepType.Delay) return [];
+    const { delay_for: duration , delay_until_field_path: field_path  } = step.settings;
+    return [
+        duration && `Delay duration: ${duration.value} ${duration.unit}`,
+        field_path && `Delay duration: "${field_path}"`
+    ];
+};
+const httpFetchStepSummaryLines = (step)=>{
+    if (step.type !== _types.StepType.HttpFetch) return [];
+    const { method , url , headers , query_params , body  } = step.settings;
+    const reqHeaders = (headers || []).map((h)=>`${h.key}: ${h.value}`);
+    const params = (query_params || []).map((p)=>`${p.key}: ${p.value}`);
+    return [
+        `Method: ${method.toUpperCase()}`,
+        `URL: ${url}`,
+        reqHeaders.length > 0 && `Headers: \n  ${reqHeaders.join("\n  ")}`,
+        params.length > 0 && `Params: \n  ${params.join("\n  ")}`,
+        body && `Body: \n${body}`
+    ];
+};
+const formatStepSummary = (step)=>{
+    const lines = [
+        // Common step attributes.
+        step.name && `Name: ${step.name}`,
+        step.description && `Description: ${step.description}`,
+        // Step type specific attributes.
+        ...channelStepSummaryLines(step),
+        ...batchStepSummaryLines(step),
+        ...delayStepSummaryLines(step),
+        ...httpFetchStepSummaryLines(step),
+        // Extra line between step rows to make it easier on the eye.
+        " "
+    ].filter((x)=>x);
+    return lines.join("\n");
+};
+const formatStatus = (workflow)=>{
+    return workflow.active ? "active" : "inactive";
+};

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_exportStar(require("./helpers"), exports);
+_exportStar(require("./reader"), exports);
+_exportStar(require("./types"), exports);
+_exportStar(require("./writer"), exports);
+function _exportStar(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) Object.defineProperty(to, k, {
+            enumerable: true,
+            get: function() {
+                return from[k];
+            }
+        });
+    });
+    return from;
+}