@knocklabs/cli 0.1.21 → 0.1.23

package/dist/commands/guide/generate-types.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return GuideGenerateTypes;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _core = require("@oclif/core");
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _const = require("../../lib/helpers/const");
+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 _request = require("../../lib/helpers/request");
+const _typegen = require("../../lib/helpers/typegen");
+const _ux = require("../../lib/helpers/ux");
+const _guide = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/guide"));
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const supportedExts = _typegen.supportedExtensions.join(", ");
+class GuideGenerateTypes extends _basecommand.default {
+    async run() {
+        const { flags } = this.props;
+        const outputFilePath = flags["output-file"].abspath;
+        const extension = _nodepath.default.extname(outputFilePath);
+        const targetLang = (0, _typegen.getLanguageFromExtension)(extension);
+        if (!targetLang) {
+            this.error(new _error.ApiError(`Unsupported file extension: ${extension}. We currently support ${supportedExts} files only.`));
+        }
+        _ux.spinner.start(`‣ Loading guides`);
+        // 1. List all guides in the target environment.
+        const guides = await this.listAllGuides();
+        _ux.spinner.stop();
+        // 2. Generate types for all guides and its step contents.
+        _ux.spinner.start(`‣ Generating types`);
+        const { result, count, mapping } = await _guide.generateTypes(guides, targetLang);
+        _ux.spinner.stop();
+        if (!result) {
+            this.log(`‣ No guides with content JSON schema found, skipping type generation`);
+            return;
+        }
+        // 3. Write the generated types to the output file.
+        await _fsextra.outputFile(outputFilePath, result.lines.join("\n"));
+        // 4. If for typescript, render and append the types index at the end.
+        if (targetLang === "typescript") {
+            const lines = _guide.generateIndexTypeTS(mapping);
+            await _fsextra.appendFile(outputFilePath, lines.join("\n"));
+        }
+        this.log(`‣ Successfully generated types for ${count} message type(s) and wrote them to ${outputFilePath}`);
+    }
+    async listAllGuides(pageParams = {}, guidesFetchedSoFar = []) {
+        const props = (0, _objectisomorphic.merge)(this.props, {
+            flags: {
+                ...pageParams,
+                limit: _page.MAX_PAGINATION_LIMIT,
+                // Generate json schemas for guide contents so we can generate types.
+                "include-json-schema": true
+            }
+        });
+        const resp = await this.apiV1.listGuides(props);
+        if (!(0, _request.isSuccessResp)(resp)) {
+            const message = (0, _request.formatErrorRespMessage)(resp);
+            this.error(new _error.ApiError(message));
+        }
+        const { entries, page_info: pageInfo } = resp.data;
+        const guides = [
+            ...guidesFetchedSoFar,
+            ...entries
+        ];
+        return pageInfo.after ? this.listAllGuides({
+            after: pageInfo.after
+        }, guides) : guides;
+    }
+}
+_define_property(GuideGenerateTypes, "description", "Generate types for all guides in an environment and write them to a file.");
+_define_property(GuideGenerateTypes, "flags", {
+    environment: _core.Flags.string({
+        summary: "Select the environment to generate types for.",
+        default: _const.KnockEnv.Development
+    }),
+    "output-file": _flag.filePath({
+        summary: `The output file to write the generated types to. We currently support ${supportedExts} files only. Your file extension will determine the target language for the generated types.`,
+        required: true
+    })
+});

package/dist/commands/guide/get.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return GuideGet;
+    }
+});
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _date = require("../../lib/helpers/date");
+const _error = require("../../lib/helpers/error");
+const _request = require("../../lib/helpers/request");
+const _ux = require("../../lib/helpers/ux");
+const _conditions = require("../../lib/marshal/conditions");
+const _helpers = require("../../lib/marshal/guide/helpers");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class GuideGet extends _basecommand.default {
+    async run() {
+        _ux.spinner.start("‣ Loading");
+        const { guide } = await this.loadGuide();
+        _ux.spinner.stop();
+        const { flags } = this.props;
+        if (flags.json) return guide;
+        this.render(guide);
+    }
+    async loadGuide() {
+        const guideResp = await this.apiV1.getGuide(this.props);
+        if (!(0, _request.isSuccessResp)(guideResp)) {
+            const message = (0, _request.formatErrorRespMessage)(guideResp);
+            _core.ux.error(new _error.ApiError(message));
+        }
+        return {
+            guide: guideResp.data
+        };
+    }
+    render(guide) {
+        const { guideKey } = this.props.args;
+        const { environment: env, "hide-uncommitted-changes": committedOnly } = this.props.flags;
+        const qualifier = env === "development" && !committedOnly ? "(including uncommitted)" : "";
+        this.log(`‣ Showing guide \`${guideKey}\` in \`${env}\` environment ${qualifier}\n`);
+        /*
+     * Guide table
+     */ const rows = [
+            {
+                key: "Name",
+                value: guide.name
+            },
+            {
+                key: "Key",
+                value: guide.key
+            },
+            {
+                key: "Type",
+                value: guide.type || "-"
+            },
+            {
+                key: "Status",
+                value: (0, _helpers.formatStatusWithSchedule)(guide)
+            },
+            {
+                key: "Description",
+                value: guide.description || "-"
+            },
+            {
+                key: "Content",
+                value: guide.steps.length > 0 ? (0, _helpers.formatStep)(guide.steps[0]) : "-"
+            },
+            {
+                key: "Targeting audience",
+                value: guide.target_audience_key || "(All users)"
+            },
+            {
+                key: "Targeting conditions",
+                value: guide.target_property_conditions ? (0, _conditions.formatConditions)(guide.target_property_conditions) : "-"
+            },
+            {
+                key: "Activation",
+                value: (0, _helpers.formatActivationRules)(guide.activation_location_rules)
+            },
+            {
+                key: "Created at",
+                value: (0, _date.formatDateTime)(guide.created_at)
+            },
+            {
+                key: "Updated at",
+                value: (0, _date.formatDateTime)(guide.updated_at)
+            }
+        ];
+        _core.ux.table(rows, {
+            key: {
+                header: "Guide",
+                minWidth: 24
+            },
+            value: {
+                header: "",
+                minWidth: 24
+            }
+        });
+        this.log("");
+    }
+}
+_define_property(GuideGet, "summary", "Display a single guide from an environment.");
+// Hide until guides are released in GA.
+_define_property(GuideGet, "hidden", true);
+_define_property(GuideGet, "flags", {
+    environment: _core.Flags.string({
+        default: "development",
+        summary: "The environment to use."
+    }),
+    "hide-uncommitted-changes": _core.Flags.boolean({
+        summary: "Hide any uncommitted changes."
+    })
+});
+_define_property(GuideGet, "args", {
+    guideKey: _core.Args.string({
+        required: true
+    })
+});
+_define_property(GuideGet, "enableJsonFlag", true);

package/dist/commands/guide/list.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return GuideList;
+    }
+});
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _date = require("../../lib/helpers/date");
+const _objectisomorphic = require("../../lib/helpers/object.isomorphic");
+const _page = require("../../lib/helpers/page");
+const _request = require("../../lib/helpers/request");
+const _helpers = require("../../lib/marshal/guide/helpers");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class GuideList extends _basecommand.default {
+    async run() {
+        const resp = await this.request();
+        const { flags } = this.props;
+        if (flags.json) return resp.data;
+        this.render(resp.data);
+    }
+    async request(pageParams = {}) {
+        const props = (0, _objectisomorphic.merge)(this.props, {
+            flags: {
+                ...pageParams
+            }
+        });
+        return (0, _request.withSpinner)(()=>this.apiV1.listGuides(props));
+    }
+    async render(data) {
+        const { entries } = data;
+        const { environment: env, "hide-uncommitted-changes": committedOnly } = this.props.flags;
+        const qualifier = env === "development" && !committedOnly ? "(including uncommitted)" : "";
+        this.log(`‣ Showing ${entries.length} guides in \`${env}\` environment ${qualifier}\n`);
+        /*
+     * Guides list table
+     */ _core.ux.table(entries, {
+            key: {
+                header: "Key"
+            },
+            name: {
+                header: "Name"
+            },
+            type: {
+                header: "Type",
+                get: (entry)=>entry.type || "-"
+            },
+            channel: {
+                header: "Channel",
+                get: (entry)=>entry.channel_key || "-"
+            },
+            status: {
+                header: "Status",
+                get: (entry)=>(0, _helpers.formatStatusWithSchedule)(entry)
+            },
+            description: {
+                header: "Description",
+                get: (entry)=>entry.description || "-"
+            },
+            updated_at: {
+                header: "Updated at",
+                get: (entry)=>(0, _date.formatDate)(entry.updated_at)
+            }
+        });
+        return this.prompt(data);
+    }
+    async prompt(data) {
+        const { page_info } = data;
+        const pageAction = await (0, _page.maybePromptPageAction)(page_info);
+        const pageParams = pageAction && (0, _page.paramsForPageAction)(pageAction, page_info);
+        if (pageParams) {
+            this.log("\n");
+            const resp = await this.request(pageParams);
+            return this.render(resp.data);
+        }
+    }
+}
+_define_property(GuideList, "summary", "Display all guides for an environment.");
+// Hide until guides are released in GA.
+_define_property(GuideList, "hidden", true);
+_define_property(GuideList, "flags", {
+    environment: _core.Flags.string({
+        default: "development",
+        summary: "The environment to use."
+    }),
+    "hide-uncommitted-changes": _core.Flags.boolean({
+        summary: "Hide any uncommitted changes."
+    }),
+    ..._page.pageFlags
+});
+_define_property(GuideList, "enableJsonFlag", true);

package/dist/commands/guide/pull.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return GuidePull;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+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 _request = require("../../lib/helpers/request");
+const _ux = require("../../lib/helpers/ux");
+const _guide = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/guide"));
+const _runcontext = require("../../lib/run-context");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+class GuidePull extends _basecommand.default {
+    async run() {
+        const { args, flags } = this.props;
+        if (flags.all && args.guideKey) {
+            return this.error(`guideKey arg \`${args.guideKey}\` cannot also be provided when using --all`);
+        }
+        return flags.all ? this.pullAllGuides() : this.pullOneGuide();
+    }
+    async pullOneGuide() {
+        const { flags } = this.props;
+        const dirContext = await this.getGuideDirContext();
+        if (dirContext.exists) {
+            this.log(`‣ Found \`${dirContext.key}\` at ${dirContext.abspath}`);
+        } else {
+            const prompt = `Create a new guide directory \`${dirContext.key}\` at ${dirContext.abspath}?`;
+            const input = flags.force || await (0, _ux.promptToConfirm)(prompt);
+            if (!input) return;
+        }
+        const resp = await (0, _request.withSpinner)(()=>{
+            const props = (0, _objectisomorphic.merge)(this.props, {
+                args: {
+                    guideKey: dirContext.key
+                },
+                flags: {
+                    annotate: true
+                }
+            });
+            return this.apiV1.getGuide(props);
+        });
+        await _guide.writeGuideDirFromData(dirContext, resp.data);
+        const action = dirContext.exists ? "updated" : "created";
+        this.log(`‣ Successfully ${action} \`${dirContext.key}\` at ${dirContext.abspath}`);
+    }
+    async pullAllGuides() {
+        const { flags } = this.props;
+        const defaultToCwd = {
+            abspath: this.runContext.cwd,
+            exists: true
+        };
+        const targetDirCtx = flags["guides-dir"] || defaultToCwd;
+        const prompt = targetDirCtx.exists ? `Pull latest guides into ${targetDirCtx.abspath}?\n  This will overwrite the contents of this directory.` : `Create a new guides directory at ${targetDirCtx.abspath}?`;
+        const input = flags.force || await (0, _ux.promptToConfirm)(prompt);
+        if (!input) return;
+        _ux.spinner.start(`‣ Loading`);
+        const guides = await this.listAllGuides();
+        await _guide.writeGuidesIndexDir(targetDirCtx, guides);
+        _ux.spinner.stop();
+        const action = targetDirCtx.exists ? "updated" : "created";
+        this.log(`‣ Successfully ${action} the guides directory at ${targetDirCtx.abspath}`);
+    }
+    async listAllGuides(pageParams = {}, guidesFetchedSoFar = []) {
+        const props = (0, _objectisomorphic.merge)(this.props, {
+            flags: {
+                ...pageParams,
+                annotate: true,
+                limit: _page.MAX_PAGINATION_LIMIT
+            }
+        });
+        const resp = await this.apiV1.listGuides(props);
+        if (!(0, _request.isSuccessResp)(resp)) {
+            const message = (0, _request.formatErrorRespMessage)(resp);
+            this.error(new _error.ApiError(message));
+        }
+        const { entries, page_info: pageInfo } = resp.data;
+        const guides = [
+            ...guidesFetchedSoFar,
+            ...entries
+        ];
+        return pageInfo.after ? this.listAllGuides({
+            after: pageInfo.after
+        }, guides) : guides;
+    }
+    async getGuideDirContext() {
+        const { guideKey } = this.props.args;
+        const { resourceDir, cwd: runCwd } = this.runContext;
+        // Inside an existing resource dir, use it if valid for the target guide.
+        if (resourceDir) {
+            const target = {
+                commandId: _basecommand.default.id,
+                type: "guide",
+                key: guideKey
+            };
+            return (0, _runcontext.ensureResourceDirForTarget)(resourceDir, target);
+        }
+        // Not inside any existing guide directory, which means either create a
+        // new guide directory in the cwd, or update it if there is one already.
+        if (guideKey) {
+            const dirPath = _nodepath.resolve(runCwd, guideKey);
+            const exists = await _guide.isGuideDir(dirPath);
+            return {
+                type: "guide",
+                key: guideKey,
+                abspath: dirPath,
+                exists
+            };
+        }
+        // Not in any guide directory, nor a guide key arg was given so error.
+        return this.error("Missing 1 required arg:\nguideKey");
+    }
+}
+// Hide until guides are released in GA.
+_define_property(GuidePull, "hidden", true);
+_define_property(GuidePull, "summary", "Pull one or more guides from an environment into a local file system.");
+_define_property(GuidePull, "flags", {
+    environment: _core.Flags.string({
+        default: "development",
+        summary: "The environment to use."
+    }),
+    all: _core.Flags.boolean({
+        summary: "Whether to pull all guides from the specified environment."
+    }),
+    "guides-dir": _flag.dirPath({
+        summary: "The target directory path to pull all guides into.",
+        dependsOn: [
+            "all"
+        ]
+    }),
+    "hide-uncommitted-changes": _core.Flags.boolean({
+        summary: "Hide any uncommitted changes."
+    }),
+    force: _core.Flags.boolean({
+        summary: "Remove the confirmation prompt."
+    })
+});
+_define_property(GuidePull, "args", {
+    guideKey: _core.Args.string({
+        required: false
+    })
+});