@knocklabs/cli 0.1.19 → 0.1.21

package/dist/lib/marshal/message-type/writer.js

@@ -0,0 +1,175 @@
+"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, {
+    pruneMessageTypesIndexDir: function() {
+        return pruneMessageTypesIndexDir;
+    },
+    writeMessageTypeDirFromData: function() {
+        return writeMessageTypeDirFromData;
+    },
+    writeMessageTypesIndexDir: function() {
+        return writeMessageTypesIndexDir;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _lodash = require("lodash");
+const _const = require("../../helpers/const");
+const _json = require("../../helpers/json");
+const _helpers = require("./helpers");
+const _processorisomorphic = require("./processor.isomorphic");
+const _reader = require("./reader");
+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 writeMessageTypeDirFromData = async (messageTypeDirCtx, remoteMessageType)=>{
+    // If the message type directory exists on the file system (i.e. previously
+    // pulled before), then read the message type file to use as a reference.
+    const [localMessageType] = messageTypeDirCtx.exists ? await (0, _reader.readMessageTypeDir)(messageTypeDirCtx, {
+        withExtractedFiles: true
+    }) : [];
+    const bundle = (0, _processorisomorphic.buildMessageTypeDirBundle)(remoteMessageType, localMessageType);
+    return writeMessageTypeDirFromBundle(messageTypeDirCtx, bundle);
+};
+/*
+ * A lower level write function that takes a constructed message type dir bundle
+ * and writes it into a message type directory on a local file system.
+ *
+ * It does not make any assumptions about how the message type directory bundle
+ * was built; for example, it can be from parsing the message type data fetched
+ * from the Knock API, or built manually for scaffolding purposes.
+ */ const writeMessageTypeDirFromBundle = async (messageTypeDirCtx, messageTypeDirBundle)=>{
+    const backupDirPath = _nodepath.resolve(_const.sandboxDir, (0, _lodash.uniqueId)("backup"));
+    try {
+        if (messageTypeDirCtx.exists) {
+            await _fsextra.copy(messageTypeDirCtx.abspath, backupDirPath);
+            await _fsextra.emptyDir(messageTypeDirCtx.abspath);
+        }
+        const promises = Object.entries(messageTypeDirBundle).map(([relpath, fileContent])=>{
+            const filePath = _nodepath.resolve(messageTypeDirCtx.abspath, relpath);
+            return relpath === _processorisomorphic.MESSAGE_TYPE_JSON ? _fsextra.outputJson(filePath, fileContent, {
+                spaces: _json.DOUBLE_SPACES
+            }) : _fsextra.outputFile(filePath, fileContent !== null && fileContent !== void 0 ? fileContent : "");
+        });
+        await Promise.all(promises);
+    } catch (error) {
+        // In case of any error, wipe the target directory that is likely in a bad
+        // state then restore the backup if one existed before.
+        if (messageTypeDirCtx.exists) {
+            await _fsextra.emptyDir(messageTypeDirCtx.abspath);
+            await _fsextra.copy(backupDirPath, messageTypeDirCtx.abspath);
+        } else {
+            await _fsextra.remove(messageTypeDirCtx.abspath);
+        }
+        throw error;
+    } finally{
+        // Always clean up the backup directory in the temp sandbox.
+        await _fsextra.remove(backupDirPath);
+    }
+};
+/*
+ * Prunes the index directory by removing any files, or directories that aren't
+ * message type dirs found in fetched message types. We want to preserve any
+ * message type dirs that are going to be updated with remote message types, so
+ * extracted links can be respected.
+ */ const pruneMessageTypesIndexDir = async (indexDirCtx, remoteMessageTypes)=>{
+    const messageTypesByKey = Object.fromEntries(remoteMessageTypes.map((w)=>[
+            w.key.toLowerCase(),
+            w
+        ]));
+    const dirents = await _fsextra.readdir(indexDirCtx.abspath, {
+        withFileTypes: true
+    });
+    const promises = dirents.map(async (dirent)=>{
+        const direntName = dirent.name.toLowerCase();
+        const direntPath = _nodepath.resolve(indexDirCtx.abspath, direntName);
+        if (await (0, _helpers.isMessageTypeDir)(direntPath) && messageTypesByKey[direntName]) {
+            return;
+        }
+        await _fsextra.remove(direntPath);
+    });
+    await Promise.all(promises);
+};
+const writeMessageTypesIndexDir = async (indexDirCtx, remoteMessageTypes)=>{
+    const backupDirPath = _nodepath.resolve(_const.sandboxDir, (0, _lodash.uniqueId)("backup"));
+    try {
+        // If the index directory already exists, back it up in the temp sandbox
+        // before wiping it clean.
+        if (indexDirCtx.exists) {
+            await _fsextra.copy(indexDirCtx.abspath, backupDirPath);
+            await pruneMessageTypesIndexDir(indexDirCtx, remoteMessageTypes);
+        }
+        // Write given remote message types into the given message types dir path.
+        const promises = remoteMessageTypes.map(async (messageType)=>{
+            const messageTypeDirPath = _nodepath.resolve(indexDirCtx.abspath, messageType.key);
+            const messageTypeDirCtx = {
+                type: "message_type",
+                key: messageType.key,
+                abspath: messageTypeDirPath,
+                exists: indexDirCtx.exists ? await (0, _helpers.isMessageTypeDir)(messageTypeDirPath) : false
+            };
+            return writeMessageTypeDirFromData(messageTypeDirCtx, messageType);
+        });
+        await Promise.all(promises);
+    } catch (error) {
+        console.log(error);
+        // In case of any error, wipe the index directory that is likely in a bad
+        // state then restore the backup if one existed before.
+        if (indexDirCtx.exists) {
+            await _fsextra.emptyDir(indexDirCtx.abspath);
+            await _fsextra.copy(backupDirPath, indexDirCtx.abspath);
+        } else {
+            await _fsextra.remove(indexDirCtx.abspath);
+        }
+        throw error;
+    } finally{
+        // Always clean up the backup directory in the temp sandbox.
+        await _fsextra.remove(backupDirPath);
+    }
+};

package/dist/lib/marshal/partial/reader.js

@@ -76,7 +76,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
 /*
  * For the given list of partial directory contexts, read each partial dir and
  * return partial directory data.
- */ const readPartialsDirs = async (partialDirCtxs, opts = {})=>{
+ */ const readPartialDirs = async (partialDirCtxs, opts = {})=>{
     const partials = [];
     const errors = [];
     for (const partialDirCtx of partialDirCtxs){
@@ -170,7 +170,7 @@ const readAllForCommandTarget = async (target, opts = {})=>{
     switch(targetType){
         case "partialDir":
             {
-                return readPartialsDirs([
+                return readPartialDirs([
                     targetCtx
                 ], opts);
             }
@@ -190,7 +190,7 @@ const readAllForCommandTarget = async (target, opts = {})=>{
                     return partialDirCtx;
                 });
                 const partialDirCtxs = (await Promise.all(promises)).filter((partialDirCtx)=>partialDirCtx.exists);
-                return readPartialsDirs(partialDirCtxs, opts);
+                return readPartialDirs(partialDirCtxs, opts);
             }
         default:
             throw new Error(`Invalid partial command target: ${target}`);

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

@@ -8,10 +8,10 @@ Object.defineProperty(exports, "PartialType", {
         return PartialType;
     }
 });
-var PartialType;
-(function(PartialType) {
+var PartialType = /*#__PURE__*/ function(PartialType) {
     PartialType["Html"] = "html";
     PartialType["Json"] = "json";
     PartialType["Markdown"] = "markdown";
     PartialType["Text"] = "text";
-})(PartialType || (PartialType = {}));
+    return PartialType;
+}({});

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

@@ -8,12 +8,12 @@ Object.defineProperty(exports, "StepType", {
         return StepType;
     }
 });
-var StepType;
-(function(StepType) {
+var StepType = /*#__PURE__*/ function(StepType) {
     StepType["Channel"] = "channel";
     StepType["Batch"] = "batch";
     StepType["Delay"] = "delay";
     StepType["HttpFetch"] = "http_fetch";
     StepType["Branch"] = "branch";
     StepType["Throttle"] = "throttle";
-})(StepType || (StepType = {}));
+    return StepType;
+}({});

package/dist/lib/run-context/loader.js

@@ -14,6 +14,8 @@ Object.defineProperty(exports, "load", {
 });
 const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
 const _emaillayout = /*#__PURE__*/ _interop_require_wildcard(require("../marshal/email-layout"));
+const _messagetype = /*#__PURE__*/ _interop_require_wildcard(require("../marshal/message-type"));
+const _partial = /*#__PURE__*/ _interop_require_wildcard(require("../marshal/partial"));
 const _translation = /*#__PURE__*/ _interop_require_wildcard(require("../marshal/translation"));
 const _workflow = /*#__PURE__*/ _interop_require_wildcard(require("../marshal/workflow"));
 function _getRequireWildcardCache(nodeInterop) {
@@ -57,38 +59,40 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+const buildResourceDirContext = (type, currDir)=>{
+    return {
+        type,
+        key: _nodepath.basename(currDir),
+        abspath: currDir,
+        exists: true
+    };
+};
 const evaluateRecursively = async (ctx, currDir)=>{
-    // Check if we are inside a workflow directory, and if so update the context.
-    const isWorkflowDir = await _workflow.isWorkflowDir(currDir);
-    if (!ctx.resourceDir && isWorkflowDir) {
-        ctx.resourceDir = {
-            type: "workflow",
-            key: _nodepath.basename(currDir),
-            abspath: currDir,
-            exists: true
-        };
-    }
-    // Check if we are inside a layout directory, and if so update the context.
-    const isEmailLayoutDir = await _emaillayout.isEmailLayoutDir(currDir);
-    if (!ctx.resourceDir && isEmailLayoutDir) {
-        ctx.resourceDir = {
-            type: "email_layout",
-            key: _nodepath.basename(currDir),
-            abspath: currDir,
-            exists: true
-        };
-    }
-    // NOTE: Must keep this check as last in the order of directory-type checks
-    // since the `isTranslationDir` only checks that the directory name is a
-    // valid locale name.
-    const isTranslationDir = _translation.isTranslationDir(currDir);
-    if (!ctx.resourceDir && isTranslationDir) {
-        ctx.resourceDir = {
-            type: "translation",
-            key: _nodepath.basename(currDir),
-            abspath: currDir,
-            exists: true
-        };
+    // Check if we are inside a resource directory and if so update the context.
+    if (!ctx.resourceDir) {
+        const isWorkflowDir = await _workflow.isWorkflowDir(currDir);
+        if (isWorkflowDir) {
+            ctx.resourceDir = buildResourceDirContext("workflow", currDir);
+        }
+        const isEmailLayoutDir = await _emaillayout.isEmailLayoutDir(currDir);
+        if (isEmailLayoutDir) {
+            ctx.resourceDir = buildResourceDirContext("email_layout", currDir);
+        }
+        const isPartialDir = await _partial.isPartialDir(currDir);
+        if (isPartialDir) {
+            ctx.resourceDir = buildResourceDirContext("partial", currDir);
+        }
+        const isMessageTypeDir = await _messagetype.isMessageTypeDir(currDir);
+        if (isMessageTypeDir) {
+            ctx.resourceDir = buildResourceDirContext("message_type", currDir);
+        }
+        // NOTE: Must keep this check as last in the order of directory-type checks
+        // since the `isTranslationDir` only checks that the directory name is a
+        // valid locale name.
+        const isTranslationDir = _translation.isTranslationDir(currDir);
+        if (isTranslationDir) {
+            ctx.resourceDir = buildResourceDirContext("translation", currDir);
+        }
     }
     // If we've identified the resource context, no need to go further.
     // TODO: In the future, consider supporting a knock project config file which

package/dist/lib/type-generator.js

@@ -0,0 +1,100 @@
+"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, {
+    generateWorkflowTypes: function() {
+        return generateWorkflowTypes;
+    },
+    getLanguageFromExtension: function() {
+        return getLanguageFromExtension;
+    }
+});
+const _quicktypecore = require("quicktype-core");
+function getLanguageFromExtension(extension) {
+    switch(extension){
+        case "ts":
+            return "typescript";
+        case "py":
+            return "python";
+        case "go":
+            return "go";
+        case "rb":
+            return "ruby";
+        default:
+            return undefined;
+    }
+}
+/**
+ * Transforms the schema to add additionalProperties to all objects.
+ *
+ * TODO: handle refs, union types, and more.
+ *
+ * @param schema The schema to transform
+ * @returns The transformed schema
+ */ 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;
+}
+/**
+ * Given a set of workflows, will go through and generated types for each workflow.
+ *
+ * If the workflow has no trigger data JSON schema, will return empty lines.
+ *
+ * @param workflows List of workflows to generate types for
+ * @param targetLanguage Target programming language for type generation
+ * @returns Generated type definitions for the workflows
+ */ async function generateWorkflowTypes(workflows, targetLanguage) {
+    const validWorkflows = workflows.filter((workflow)=>workflow.trigger_data_json_schema);
+    if (validWorkflows.length === 0) {
+        return {
+            result: undefined,
+            workflows: []
+        };
+    }
+    const schemaInput = new _quicktypecore.JSONSchemaInput(new _quicktypecore.FetchingJSONSchemaStore());
+    for (const workflow of validWorkflows){
+        const pascalCaseWorkflowKey = workflow.key.split(/[_-]/).map((part)=>part.charAt(0).toUpperCase() + part.slice(1)).join("");
+        const schema = transformSchema({
+            ...workflow.trigger_data_json_schema,
+            title: `${pascalCaseWorkflowKey}Data`
+        });
+        schemaInput.addSource({
+            name: `${pascalCaseWorkflowKey}Data`,
+            schema: JSON.stringify(schema)
+        });
+    }
+    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,
+        workflows: validWorkflows
+    };
+}