@knocklabs/cli 0.1.22 → 0.2.0

package/bin/dev.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node_modules/.bin/ts-node
 // eslint-disable-next-line node/shebang, unicorn/prefer-top-level-await
-;(async () => {
-  const oclif = await import('@oclif/core')
-  await oclif.execute({development: true, dir: __dirname})
-})()
+(async () => {
+  const oclif = await import("@oclif/core");
+  await oclif.execute({ development: true, dir: __dirname });
+})();

package/dist/commands/commit/list.js

@@ -35,8 +35,14 @@ function _interop_require_default(obj) {
 }
 class CommitList extends _basecommand.default {
     async run() {
-        const resp = await this.request();
+        // Validate that resource-type and resource-id are used together
         const { flags } = this.props;
+        const hasResourceType = Boolean(flags["resource-type"]);
+        const hasResourceId = Boolean(flags["resource-id"]);
+        if (hasResourceType !== hasResourceId) {
+            this.error("The --resource-type and --resource-id flags must be used together. " + "You cannot use one without the other.");
+        }
+        const resp = await this.request();
         if (flags.json) return resp.data;
         this.render(resp.data);
     }
@@ -109,6 +115,20 @@ _define_property(CommitList, "flags", {
         summary: "Show only promoted or unpromoted changes between the given environment and the subsequent environment.",
         allowNo: true
     }),
+    "resource-type": _core.Flags.string({
+        summary: "Filter commits by resource type. Must be used together with resource-id.",
+        options: [
+            "email_layout",
+            "guide",
+            "message_type",
+            "partial",
+            "translation",
+            "workflow"
+        ]
+    }),
+    "resource-id": _core.Flags.string({
+        summary: "Filter commits by resource identifier. Must be used together with resource-type. For most resources, this will be the resource key. In the case of translations, this will be the locale code and namespace, separated by a /. For example, en/courses or en."
+    }),
     ..._page.pageFlags
 });
 _define_property(CommitList, "enableJsonFlag", true);

package/dist/commands/guide/activate.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return GuideActivate;
+    }
+});
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _flag = require("../../lib/helpers/flag");
+const _request = require("../../lib/helpers/request");
+const _ux = require("../../lib/helpers/ux");
+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 GuideActivate extends _basecommand.default {
+    async run() {
+        const { args, flags } = this.props;
+        // Validate that either status OR from/until is provided
+        const hasStatus = flags.status !== undefined;
+        const hasFrom = Boolean(flags.from);
+        const hasUntil = Boolean(flags.until);
+        if (!hasStatus && !hasFrom && !hasUntil) {
+            this.error("Either --status or --from/--until must be provided");
+        }
+        let action;
+        if (hasStatus) {
+            action = flags.status ? "Activate" : "Deactivate";
+        } else if (hasFrom && hasUntil) {
+            action = `Schedule activation from ${flags.from} until ${flags.until}`;
+        } else if (hasFrom) {
+            action = `Activate from ${flags.from}`;
+        } else {
+            action = `Deactivate at ${flags.until}`;
+        }
+        // 1. Confirm before activating or deactivating the guide, unless forced.
+        const prompt = `${action} \`${args.guideKey}\` guide in \`${flags.environment}\` environment?`;
+        const input = flags.force || await (0, _ux.promptToConfirm)(prompt);
+        if (!input) return;
+        // 2. Proceed to make a request to set the guide status.
+        let actioning;
+        if (hasStatus) {
+            actioning = flags.status ? "Activating" : "Deactivating";
+        } else {
+            actioning = "Scheduling activation";
+        }
+        await (0, _request.withSpinner)(()=>{
+            return this.apiV1.activateGuide(this.props);
+        }, {
+            action: `‣ ${actioning}`
+        });
+        let actioned;
+        if (hasStatus) {
+            actioned = flags.status ? "activated" : "deactivated";
+        } else {
+            actioned = "scheduled";
+        }
+        this.log(`‣ Successfully ${actioned} \`${args.guideKey}\` guide in \`${flags.environment}\` environment`);
+    }
+}
+_define_property(GuideActivate, "summary", "Activate or deactivate a guide in a given environment.");
+_define_property(GuideActivate, "description", `
+This enables or disables a guide in a given environment without
+needing to go through environment promotion.
+
+You can activate or deactivate a guide immediately or schedule it to be activated 
+or deactivated at a later time using the --from and --until flags.
+`.trim());
+_define_property(GuideActivate, "flags", {
+    // Do not default to any env for this command, since this action runs
+    // directly in each environment outside the commit and promote flow.
+    environment: _core.Flags.string({
+        required: true,
+        summary: "The environment to use."
+    }),
+    status: (0, _flag.booleanStr)({
+        summary: "The guide active status to set. Cannot be used with --from/--until.",
+        exclusive: [
+            "from",
+            "until"
+        ]
+    }),
+    from: _core.Flags.string({
+        summary: "Activate the guide from this ISO8601 UTC datetime (e.g., '2024-01-15T10:30:00Z').",
+        exclusive: [
+            "status"
+        ]
+    }),
+    until: _core.Flags.string({
+        summary: "Deactivate the guide at this ISO8601 UTC datetime (e.g., '2024-01-15T18:30:00Z').",
+        exclusive: [
+            "status"
+        ]
+    }),
+    force: _core.Flags.boolean({
+        summary: "Remove the confirmation prompt."
+    })
+});
+_define_property(GuideActivate, "args", {
+    guideKey: _core.Args.string({
+        required: true
+    })
+});

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);