@knocklabs/cli 0.1.22 → 0.1.23

package/dist/lib/helpers/string.js

@@ -7,14 +7,14 @@ Object.defineProperty(exports, "__esModule", {
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
         enumerable: true,
-        get: all[name]
+        get: Object.getOwnPropertyDescriptor(all, name).get
     });
 }
 _export(exports, {
-    checkSlugifiedFormat: function() {
+    get checkSlugifiedFormat () {
         return checkSlugifiedFormat;
     },
-    indentString: function() {
+    get indentString () {
         return indentString;
     }
 });

package/dist/lib/helpers/typegen.js

@@ -0,0 +1,59 @@
+"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 getLanguageFromExtension () {
+        return getLanguageFromExtension;
+    },
+    get supportedExtensions () {
+        return supportedExtensions;
+    },
+    get transformSchema () {
+        return transformSchema;
+    }
+});
+const supportedExtensions = [
+    ".ts",
+    ".py",
+    ".go",
+    ".rb"
+];
+function getLanguageFromExtension(extension) {
+    switch(extension){
+        case "ts":
+        case ".ts":
+            return "typescript";
+        case "py":
+        case ".py":
+            return "python";
+        case "go":
+        case ".go":
+            return "go";
+        case "rb":
+        case ".rb":
+            return "ruby";
+        default:
+            return undefined;
+    }
+}
+function transformSchema(schema) {
+    if (schema.type === "object" && !schema.additionalProperties) {
+        schema.additionalProperties = false;
+    }
+    var _schema_properties;
+    for (const key of Object.keys((_schema_properties = schema.properties) !== null && _schema_properties !== void 0 ? _schema_properties : {})){
+        const property = schema.properties[key];
+        if (property.type === "object") {
+            const transformedProperty = transformSchema(property);
+            schema.properties[key] = transformedProperty;
+        }
+    }
+    return schema;
+}

package/dist/lib/helpers/ux.js

@@ -5,14 +5,14 @@ Object.defineProperty(exports, "__esModule", {
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
         enumerable: true,
-        get: all[name]
+        get: Object.getOwnPropertyDescriptor(all, name).get
     });
 }
 _export(exports, {
-    promptToConfirm: function() {
+    get promptToConfirm () {
         return promptToConfirm;
     },
-    spinner: function() {
+    get spinner () {
         return spinner;
     }
 });

package/dist/lib/marshal/email-layout/helpers.js

@@ -5,20 +5,20 @@ Object.defineProperty(exports, "__esModule", {
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
         enumerable: true,
-        get: all[name]
+        get: Object.getOwnPropertyDescriptor(all, name).get
     });
 }
 _export(exports, {
-    emailLayoutJsonPath: function() {
+    get emailLayoutJsonPath () {
         return emailLayoutJsonPath;
     },
-    ensureValidCommandTarget: function() {
+    get ensureValidCommandTarget () {
         return ensureValidCommandTarget;
     },
-    isEmailLayoutDir: function() {
+    get isEmailLayoutDir () {
         return isEmailLayoutDir;
     },
-    lsEmailLayoutJson: function() {
+    get lsEmailLayoutJson () {
         return lsEmailLayoutJson;
     }
 });

package/dist/lib/marshal/email-layout/processor.isomorphic.js

@@ -5,14 +5,14 @@ Object.defineProperty(exports, "__esModule", {
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
         enumerable: true,
-        get: all[name]
+        get: Object.getOwnPropertyDescriptor(all, name).get
     });
 }
 _export(exports, {
-    LAYOUT_JSON: function() {
+    get LAYOUT_JSON () {
         return LAYOUT_JSON;
     },
-    buildEmailLayoutDirBundle: function() {
+    get buildEmailLayoutDirBundle () {
         return buildEmailLayoutDirBundle;
     }
 });

package/dist/lib/marshal/email-layout/reader.js

@@ -5,14 +5,14 @@ Object.defineProperty(exports, "__esModule", {
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
         enumerable: true,
-        get: all[name]
+        get: Object.getOwnPropertyDescriptor(all, name).get
     });
 }
 _export(exports, {
-    readAllForCommandTarget: function() {
+    get readAllForCommandTarget () {
         return readAllForCommandTarget;
     },
-    readEmailLayoutDir: function() {
+    get readEmailLayoutDir () {
         return readEmailLayoutDir;
     }
 });
@@ -135,7 +135,7 @@ const readAllForCommandTarget = async (target, opts = {})=>{
 };
 const readEmailLayoutDir = async (layoutDirCtx, opts = {})=>{
     const { abspath } = layoutDirCtx;
-    const { withExtractedFiles = false, withReadonlyField = false } = opts;
+    const { withExtractedFiles = false } = opts;
     const dirExists = await _fsextra.pathExists(abspath);
     if (!dirExists) throw new Error(`${abspath} does not exist`);
     const layoutJsonPath = await (0, _helpers1.lsEmailLayoutJson)(abspath);
@@ -143,7 +143,7 @@ const readEmailLayoutDir = async (layoutDirCtx, opts = {})=>{
     const result = await (0, _json.readJson)(layoutJsonPath);
     if (!result[0]) return result;
     let [layoutJson] = result;
-    layoutJson = withReadonlyField ? layoutJson : (0, _objectisomorphic.omitDeep)(layoutJson, [
+    layoutJson = (0, _objectisomorphic.omitDeep)(layoutJson, [
         "__readonly"
     ]);
     return withExtractedFiles ? joinExtractedFiles(layoutDirCtx, layoutJson) : [

package/dist/lib/marshal/email-layout/writer.js

@@ -5,17 +5,17 @@ Object.defineProperty(exports, "__esModule", {
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
         enumerable: true,
-        get: all[name]
+        get: Object.getOwnPropertyDescriptor(all, name).get
     });
 }
 _export(exports, {
-    pruneLayoutsIndexDir: function() {
+    get pruneLayoutsIndexDir () {
         return pruneLayoutsIndexDir;
     },
-    writeEmailLayoutDirFromData: function() {
+    get writeEmailLayoutDirFromData () {
         return writeEmailLayoutDirFromData;
     },
-    writeEmailLayoutIndexDir: function() {
+    get writeEmailLayoutIndexDir () {
         return writeEmailLayoutIndexDir;
     }
 });

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

@@ -0,0 +1,283 @@
+"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 ensureValidCommandTarget () {
+        return ensureValidCommandTarget;
+    },
+    get formatActivationRules () {
+        return formatActivationRules;
+    },
+    get formatStatusWithSchedule () {
+        return formatStatusWithSchedule;
+    },
+    get formatStep () {
+        return formatStep;
+    },
+    get generateIndexTypeTS () {
+        return generateIndexTypeTS;
+    },
+    get generateTypes () {
+        return generateTypes;
+    },
+    get guideJsonPath () {
+        return guideJsonPath;
+    },
+    get isGuideDir () {
+        return isGuideDir;
+    },
+    get lsGuideJson () {
+        return lsGuideJson;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+const _core = require("@oclif/core");
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _lodash = require("lodash");
+const _quicktypecore = require("quicktype-core");
+const _processorisomorphic = require("./processor.isomorphic");
+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 formatStatusWithSchedule = (guide)=>{
+    const baseStatus = guide.active ? "Active" : "Inactive";
+    if (guide.active_from || guide.active_until) {
+        const fromText = guide.active_from ? `from ${guide.active_from}` : "immediately";
+        const untilText = guide.active_until ? `until ${guide.active_until}` : "with no end time";
+        return `${baseStatus} (${fromText} ${untilText})`;
+    }
+    return baseStatus;
+};
+const formatStep = (step)=>{
+    return `${step.schema_key} (${step.schema_variant_key})`;
+};
+const formatActivationRules = (rules)=>{
+    if (!rules || !Array.isArray(rules)) return "-";
+    return rules.map(({ directive, pathname })=>`${directive} ${pathname}`).join(", ");
+};
+const guideJsonPath = (guideDirCtx)=>_nodepath.resolve(guideDirCtx.abspath, _processorisomorphic.GUIDE_JSON);
+const lsGuideJson = async (dirPath)=>{
+    const guideJsonPath = _nodepath.resolve(dirPath, _processorisomorphic.GUIDE_JSON);
+    const exists = await _fsextra.pathExists(guideJsonPath);
+    return exists ? guideJsonPath : undefined;
+};
+const isGuideDir = async (dirPath)=>Boolean(await lsGuideJson(dirPath));
+const ensureValidCommandTarget = async (props, runContext)=>{
+    const { args, flags } = props;
+    const { commandId, resourceDir: resourceDirCtx, cwd: runCwd } = runContext;
+    // If the target resource is a different type than the current resource dir
+    // type, error out.
+    if (resourceDirCtx && resourceDirCtx.type !== "guide") {
+        return _core.ux.error(`Cannot run ${commandId} inside a ${resourceDirCtx.type} directory`);
+    }
+    // Cannot accept both guide key arg and --all flag.
+    if (flags.all && args.guideKey) {
+        return _core.ux.error(`guideKey arg \`${args.guideKey}\` cannot also be provided when using --all`);
+    }
+    // --all flag is given, which means no guide key arg.
+    if (flags.all) {
+        // If --all flag used inside a guide directory, then require a guides
+        // dir path.
+        if (resourceDirCtx && !flags["guides-dir"]) {
+            return _core.ux.error("Missing required flag guides-dir");
+        }
+        // Targeting all guide dirs in the guides index dir.
+        // TODO: Default to the knock project config first if present before cwd.
+        const defaultToCwd = {
+            abspath: runCwd,
+            exists: true
+        };
+        const indexDirCtx = flags["guides-dir"] || defaultToCwd;
+        return {
+            type: "guidesIndexDir",
+            context: indexDirCtx
+        };
+    }
+    // Guide key arg is given, which means no --all flag.
+    if (args.guideKey) {
+        if (resourceDirCtx && resourceDirCtx.key !== args.guideKey) {
+            return _core.ux.error(`Cannot run ${commandId} \`${args.guideKey}\` inside another guide directory:\n${resourceDirCtx.key}`);
+        }
+        const targetDirPath = resourceDirCtx ? resourceDirCtx.abspath : _nodepath.resolve(runCwd, args.guideKey);
+        const guideDirCtx = {
+            type: "guide",
+            key: args.guideKey,
+            abspath: targetDirPath,
+            exists: await isGuideDir(targetDirPath)
+        };
+        return {
+            type: "guideDir",
+            context: guideDirCtx
+        };
+    }
+    // From this point on, we have neither a guide key arg nor --all flag.
+    // If running inside a guide directory, then use that guide directory.
+    if (resourceDirCtx) {
+        return {
+            type: "guideDir",
+            context: resourceDirCtx
+        };
+    }
+    return _core.ux.error("Missing 1 required arg:\nguideKey");
+};
+/*
+ * Takes an array of guides and generate types from its content json schemas.
+ */ const SCHEMA_TITLE_PREFIX = "Guide";
+async function generateTypes(guides, targetLanguage) {
+    const schemaInput = new _quicktypecore.JSONSchemaInput(new _quicktypecore.FetchingJSONSchemaStore());
+    let processedCount = 0;
+    const mapping = {
+        key: {},
+        type: {}
+    };
+    for (const guide of guides){
+        if (!guide.type) {
+            continue;
+        }
+        // We only support single step guides at the moment.
+        const step = (guide.steps || []).find((s)=>s.json_schema);
+        if (!step) {
+            continue;
+        }
+        // Format the type name that quicktype can output exactly. It's important
+        // that the names we format are used/preserved by quicktype as we create the
+        // final mapping referencing these type names.
+        // Example: `GuideBannerFourStep1Banner001Default`
+        const typeName = [
+            SCHEMA_TITLE_PREFIX,
+            startCaseNoSpace(guide.key),
+            startCaseNoSpace(step.ref),
+            startCaseNoSpace(step.schema_key),
+            startCaseNoSpace(step.schema_semver),
+            startCaseNoSpace(step.schema_variant_key)
+        ].join("");
+        schemaInput.addSource({
+            name: typeName,
+            schema: JSON.stringify({
+                ...step.json_schema,
+                title: typeName
+            })
+        });
+        mapping.key[guide.key] = typeName;
+        mapping.type[guide.type] = [
+            ...mapping.type[guide.type] || [],
+            typeName
+        ];
+        processedCount++;
+    }
+    if (processedCount === 0) {
+        return {
+            result: undefined,
+            count: 0,
+            mapping
+        };
+    }
+    const inputData = new _quicktypecore.InputData();
+    inputData.addInput(schemaInput);
+    const result = await (0, _quicktypecore.quicktype)({
+        inputData,
+        lang: targetLanguage,
+        allPropertiesOptional: false,
+        alphabetizeProperties: true,
+        rendererOptions: {
+            "just-types": true,
+            "no-extra-properties": true,
+            "no-optional-null": true
+        }
+    });
+    return {
+        result,
+        count: processedCount,
+        mapping
+    };
+}
+const startCaseNoSpace = (key)=>(0, _lodash.startCase)(key).replace(/\s/g, "");
+/*
+ * For typescript, this writes a root type that maps out all guide types by
+ * guide type and key.
+ *
+ * For example:
+ *   type GuideContentByType = {
+ *     "banner-one": GuideBannerOneStep1Banner001Default;
+ *     "banner-two": GuideBannerTwoStep1Banner001Default;
+ *     "card-one": GuideCardOneStep1Card001Default;
+ *     "card-two": GuideCardTwoStep1Card001SingleAction;
+ *     "changelog-card": GuideChangelogCardStep1ChangelogCard001SingleAction;
+ *     "modal-one": GuideModalOneStep1Modal001MultiAction;
+ *   };
+ *
+ *   type GuideContentByKey = {
+ *     "banner": GuideBannerOneStep1Banner001Default | GuideBannerTwoStep1Banner001Default;
+ *     "card": GuideCardOneStep1Card001Default | GuideCardTwoStep1Card001SingleAction;
+ *     "changelog-card": GuideChangelogCardStep1ChangelogCard001SingleAction;
+ *     "modal": GuideModalOneStep1Modal001MultiAction;
+ *   };
+ *
+ *   export type GuideContentIndex = {
+ *     key: GuideContentByType;
+ *     type: GuideContentByKey;
+ *   };
+ */ const TS_INDEX_TYPE_PREFIX = "GuideContent";
+const generateIndexTypeTS = (mapping)=>{
+    const lines = [];
+    // Define the type for sub index by guide key.
+    const byKey = `${TS_INDEX_TYPE_PREFIX}ByKey`;
+    lines.push(`\ntype ${byKey} = {`);
+    for (const [key, val] of Object.entries(mapping.key)){
+        lines.push(`  "${key}": ${val};`);
+    }
+    lines.push("};");
+    // Define the type for sub index by guide type.
+    const byType = `${TS_INDEX_TYPE_PREFIX}ByType`;
+    lines.push(`\ntype ${byType} = {`);
+    for (const [key, val] of Object.entries(mapping.type)){
+        lines.push(`  "${key}": ${(val || []).join(" | ")};`);
+    }
+    lines.push("};", `\nexport type ${TS_INDEX_TYPE_PREFIX}Index = {`, `  key: ${byKey};`, `  type: ${byType};`, "};");
+    return lines;
+};

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

@@ -2,8 +2,11 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+_export_star(require("./helpers"), exports);
 _export_star(require("./processor.isomorphic"), exports);
+_export_star(require("./reader"), exports);
 _export_star(require("./types"), exports);
+_export_star(require("./writer"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/dist/lib/marshal/guide/processor.isomorphic.js

@@ -12,14 +12,14 @@ Object.defineProperty(exports, "__esModule", {
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
         enumerable: true,
-        get: all[name]
+        get: Object.getOwnPropertyDescriptor(all, name).get
     });
 }
 _export(exports, {
-    GUIDE_JSON: function() {
+    get GUIDE_JSON () {
         return GUIDE_JSON;
     },
-    buildGuideDirBundle: function() {
+    get buildGuideDirBundle () {
         return buildGuideDirBundle;
     }
 });