@knocklabs/cli 1.1.1 → 1.2.2

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

@@ -0,0 +1,142 @@
+"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 SCHEMA_FILE_SCHEMA () {
+        return SCHEMA_FILE_SCHEMA;
+    },
+    get isSchemaItemType () {
+        return isSchemaItemType;
+    },
+    get resolveSchemasDir () {
+        return resolveSchemasDir;
+    },
+    get schemaFileContext () {
+        return schemaFileContext;
+    },
+    get schemaFilePath () {
+        return schemaFilePath;
+    },
+    get schemaTargetFromData () {
+        return schemaTargetFromData;
+    },
+    get validateSchemaCollection () {
+        return validateSchemaCollection;
+    },
+    get validateSchemaItemType () {
+        return validateSchemaItemType;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _types = require("./types");
+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 SCHEMA_FILE_SCHEMA = "https://schemas.knock.app/cli/schema.json";
+const isSchemaItemType = (value)=>_types.SCHEMA_ITEM_TYPES.includes(value);
+const validateSchemaItemType = (value)=>{
+    if (!isSchemaItemType(value)) {
+        throw new Error(`Invalid item type \`${value}\`. Must be one of: ${_types.SCHEMA_ITEM_TYPES.join(", ")}`);
+    }
+    return value;
+};
+const validateSchemaCollection = (collection)=>{
+    if (!collection || collection.includes("/") || collection.includes("\\") || collection === "." || collection === "..") {
+        throw new Error(`Invalid object collection \`${collection}\``);
+    }
+    return collection;
+};
+const resolveSchemasDir = async (projectConfig, basePath)=>{
+    const schemasDirPath = projectConfig ? _nodepath.default.resolve(_nodepath.default.isAbsolute(projectConfig.knockDir) ? projectConfig.knockDir : _nodepath.default.resolve(basePath, projectConfig.knockDir), "schemas") : _nodepath.default.resolve(basePath, "schemas");
+    const exists = await _fsextra.pathExists(schemasDirPath);
+    if (exists && !(await _fsextra.lstat(schemasDirPath)).isDirectory()) {
+        throw new Error(`${schemasDirPath} is not a directory`);
+    }
+    return {
+        abspath: schemasDirPath,
+        exists
+    };
+};
+const schemaFilePath = (schemasDirPath, itemType, collection)=>{
+    if (itemType === "object") {
+        return _nodepath.default.resolve(schemasDirPath, "objects", `${validateSchemaCollection(collection !== null && collection !== void 0 ? collection : "")}.json`);
+    }
+    return _nodepath.default.resolve(schemasDirPath, `${itemType}.json`);
+};
+const schemaFileContext = async (schemasDirPath, itemType, collection)=>{
+    const abspath = schemaFilePath(schemasDirPath, itemType, collection);
+    const exists = await _fsextra.pathExists(abspath);
+    if (exists && !(await _fsextra.lstat(abspath)).isFile()) {
+        throw new Error(`${abspath} is not a file`);
+    }
+    return {
+        itemType,
+        collection,
+        abspath,
+        exists
+    };
+};
+const schemaTargetFromData = (schema)=>{
+    const itemType = validateSchemaItemType(schema.item_type);
+    if (itemType === "object") {
+        var _schema_item_id;
+        return {
+            itemType,
+            collection: validateSchemaCollection((_schema_item_id = schema.item_id) !== null && _schema_item_id !== void 0 ? _schema_item_id : "")
+        };
+    }
+    return {
+        itemType
+    };
+};

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./helpers"), 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)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

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

@@ -0,0 +1,177 @@
+"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 readAllSchemaFiles () {
+        return readAllSchemaFiles;
+    },
+    get readSchemaFile () {
+        return readSchemaFile;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _error = require("../../helpers/error");
+const _json = require("../../helpers/json");
+const _objectisomorphic = require("../../helpers/object.isomorphic");
+const _helpers = require("./helpers");
+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 readSchemaFile = async (schemaFileCtx)=>{
+    if (!schemaFileCtx.exists) {
+        throw new Error(`Cannot locate schema file at \`${schemaFileCtx.abspath}\``);
+    }
+    const [schemaJson, readErrors] = await (0, _json.readJson)(schemaFileCtx.abspath);
+    if (!schemaJson) {
+        return [
+            undefined,
+            [
+                new _error.SourceError((0, _error.formatErrors)(readErrors), schemaFileCtx.abspath)
+            ]
+        ];
+    }
+    const schema = (0, _objectisomorphic.omitDeep)(schemaJson, [
+        "$schema",
+        "__readonly"
+    ]);
+    return [
+        schema,
+        []
+    ];
+};
+const readAllSchemaFiles = async (schemasDirPath)=>{
+    if (!await _fsextra.pathExists(schemasDirPath)) {
+        throw new Error(`Cannot locate schema files in \`${schemasDirPath}\``);
+    }
+    const schemas = [];
+    const errors = [];
+    for (const itemType of [
+        "user",
+        "tenant"
+    ]){
+        // eslint-disable-next-line no-await-in-loop
+        const ctx = await (0, _helpers.schemaFileContext)(schemasDirPath, itemType);
+        if (!ctx.exists) continue;
+        // eslint-disable-next-line no-await-in-loop
+        const [content, readErrors] = await readSchemaFile(ctx);
+        if (readErrors.length > 0) {
+            errors.push(...readErrors);
+            continue;
+        }
+        schemas.push({
+            ...ctx,
+            content: content
+        });
+    }
+    const objectsDirPath = _nodepath.default.resolve(schemasDirPath, "objects");
+    if (await _fsextra.pathExists(objectsDirPath)) {
+        const dirents = await _fsextra.readdir(objectsDirPath, {
+            withFileTypes: true
+        });
+        for (const dirent of dirents){
+            if (!dirent.isFile() || !dirent.name.endsWith(".json")) continue;
+            const collection = _nodepath.default.basename(dirent.name, ".json");
+            // An invalid filename (e.g. `..json`) fails collection validation;
+            // collect it like any other read error instead of aborting the run.
+            let ctx;
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                ctx = await (0, _helpers.schemaFileContext)(schemasDirPath, "object", collection);
+            } catch (error) {
+                errors.push(new _error.SourceError(error.message, _nodepath.default.resolve(objectsDirPath, dirent.name), "ReadError"));
+                continue;
+            }
+            // eslint-disable-next-line no-await-in-loop
+            const [content, readErrors] = await readSchemaFile(ctx);
+            if (readErrors.length > 0) {
+                errors.push(...readErrors);
+                continue;
+            }
+            schemas.push({
+                ...ctx,
+                content: content
+            });
+        }
+    }
+    const validated = [];
+    for (const schema of schemas){
+        try {
+            const itemType = (0, _helpers.validateSchemaItemType)(schema.content.item_type);
+            // The file path determines where a schema is pushed, so a file that
+            // declares a different item_type is ambiguous. Error instead of silently
+            // reinterpreting it.
+            if (itemType !== schema.itemType) {
+                throw new Error(`Schema file declares item_type \`${itemType}\` but its file path implies \`${schema.itemType}\``);
+            }
+            // Same for an object schema whose declared item_id disagrees with its
+            // objects/<collection>.json path.
+            if (itemType === "object" && schema.content.item_id && schema.content.item_id !== schema.collection) {
+                throw new Error(`Schema file declares item_id \`${schema.content.item_id}\` but its file path implies \`${schema.collection}\``);
+            }
+            validated.push({
+                ...schema,
+                content: {
+                    ...schema.content,
+                    item_type: itemType
+                }
+            });
+        } catch (error) {
+            errors.push(new _error.SourceError(error.message, schema.abspath, "ReadError"));
+        }
+    }
+    return [
+        validated,
+        errors
+    ];
+};

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SCHEMA_ITEM_TYPES", {
+    enumerable: true,
+    get: function() {
+        return SCHEMA_ITEM_TYPES;
+    }
+});
+const SCHEMA_ITEM_TYPES = [
+    "user",
+    "tenant",
+    "object"
+];

package/dist/lib/marshal/schema/writer.js

@@ -0,0 +1,154 @@
+"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 schemaJsonForWrite () {
+        return schemaJsonForWrite;
+    },
+    get writeSchemaFileFromData () {
+        return writeSchemaFileFromData;
+    },
+    get writeSchemasIndexDir () {
+        return writeSchemasIndexDir;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(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");
+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 schemaJsonForWrite = (schema)=>{
+    var _schema_item_id, _schema_item_id1;
+    return {
+        $schema: _helpers.SCHEMA_FILE_SCHEMA,
+        item_type: schema.item_type,
+        item_id: (_schema_item_id = schema.item_id) !== null && _schema_item_id !== void 0 ? _schema_item_id : null,
+        properties: schema.properties,
+        __readonly: {
+            item_type: schema.item_type,
+            item_id: (_schema_item_id1 = schema.item_id) !== null && _schema_item_id1 !== void 0 ? _schema_item_id1 : null
+        }
+    };
+};
+const writeSchemaFileFromData = async (schemaFileCtx, schema)=>{
+    await _fsextra.outputJson(schemaFileCtx.abspath, schemaJsonForWrite(schema), {
+        spaces: _json.DOUBLE_SPACES
+    });
+};
+/*
+ * Prunes schema files that are no longer present in the remote set, so a later
+ * `schema push --all` cannot push stale schemas back into the environment.
+ * Only removes the file shapes push reads (user.json, tenant.json, and
+ * objects/<collection>.json); anything else in the directory is left alone.
+ */ const pruneSchemasIndexDir = async (schemasDirPath, remoteSchemas)=>{
+    const expectedPaths = new Set(remoteSchemas.map((schema)=>{
+        const { itemType, collection } = (0, _helpers.schemaTargetFromData)(schema);
+        return (0, _helpers.schemaFilePath)(schemasDirPath, itemType, collection);
+    }));
+    const candidatePaths = [
+        _nodepath.default.resolve(schemasDirPath, "user.json"),
+        _nodepath.default.resolve(schemasDirPath, "tenant.json")
+    ];
+    const objectsDirPath = _nodepath.default.resolve(schemasDirPath, "objects");
+    if (await _fsextra.pathExists(objectsDirPath)) {
+        const dirents = await _fsextra.readdir(objectsDirPath, {
+            withFileTypes: true
+        });
+        for (const dirent of dirents){
+            if (dirent.isFile() && dirent.name.endsWith(".json")) {
+                candidatePaths.push(_nodepath.default.resolve(objectsDirPath, dirent.name));
+            }
+        }
+    }
+    await Promise.all(candidatePaths.filter((abspath)=>!expectedPaths.has(abspath)).map((abspath)=>_fsextra.remove(abspath)));
+};
+const writeSchemasIndexDir = async (schemasDirPath, schemas)=>{
+    const dirExists = await _fsextra.pathExists(schemasDirPath);
+    const backupDirPath = _nodepath.default.resolve(_const.sandboxDir, (0, _lodash.uniqueId)("backup"));
+    let backedUp = false;
+    try {
+        // If the schemas directory already exists, back it up in the temp sandbox
+        // before pruning stale files, so a failed write can restore it.
+        if (dirExists) {
+            await _fsextra.copy(schemasDirPath, backupDirPath);
+            backedUp = true;
+            await pruneSchemasIndexDir(schemasDirPath, schemas);
+        }
+        for (const schema of schemas){
+            const { itemType, collection } = (0, _helpers.schemaTargetFromData)(schema);
+            // eslint-disable-next-line no-await-in-loop
+            const ctx = await (0, _helpers.schemaFileContext)(schemasDirPath, itemType, collection);
+            // eslint-disable-next-line no-await-in-loop
+            await writeSchemaFileFromData(ctx, schema);
+        }
+    } catch (error) {
+        // In case of any error, wipe the schemas directory that is likely in a bad
+        // state then restore the backup, but only when the backup completed. If
+        // the backup copy itself failed, nothing has touched the original tree, so
+        // leave it alone.
+        if (dirExists && backedUp) {
+            await _fsextra.emptyDir(schemasDirPath);
+            await _fsextra.copy(backupDirPath, schemasDirPath);
+        } else if (!dirExists) {
+            await _fsextra.remove(schemasDirPath);
+        }
+        throw error;
+    } finally{
+        // Always clean up the backup directory in the temp sandbox.
+        await _fsextra.remove(backupDirPath);
+    }
+};

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

@@ -71,6 +71,21 @@ function _interop_require_wildcard(obj, nodeInterop) {
 const DECODABLE_JSON_FILES = new Set([
     _workflow.VISUAL_BLOCKS_JSON
 ]);
+const validateLiquidSyntaxDeep = (content)=>{
+    if (typeof content === "string") return (0, _liquid.validateLiquidSyntax)(content);
+    if (Array.isArray(content)) {
+        for (const item of content){
+            const liquidParseError = validateLiquidSyntaxDeep(item);
+            if (liquidParseError) return liquidParseError;
+        }
+    } else if (content && typeof content === "object") {
+        for (const value of Object.values(content)){
+            const liquidParseError = validateLiquidSyntaxDeep(value);
+            if (liquidParseError) return liquidParseError;
+        }
+    }
+    return undefined;
+};
 const readExtractedFileSync = (relpath, dirCtx, objPathToFieldStr = "")=>{
     // Check if the file actually exists at the given file path.
     const abspath = _nodepath.resolve(dirCtx.abspath, relpath);
@@ -85,22 +100,11 @@ const readExtractedFileSync = (relpath, dirCtx, objPathToFieldStr = "")=>{
     // Read the file and check for valid liquid syntax given it is supported
     // across all message templates and file extensions.
     const contentStr = _fsextra.readFileSync(abspath, "utf8");
-    const liquidParseError = (0, _liquid.validateLiquidSyntax)(contentStr);
-    if (liquidParseError) {
-        const error = new _error.JsonDataError(`points to a file that contains invalid liquid syntax (${relpath})\n\n` + (0, _error.formatErrors)([
-            liquidParseError
-        ], {
-            indentBy: 2
-        }), objPathToFieldStr);
-        return [
-            undefined,
-            error
-        ];
-    }
-    // If the file is expected to contain decodable json, then parse the contentStr
-    // as such.
     const fileName = _nodepath.basename(abspath.toLowerCase());
     const decodable = DECODABLE_JSON_FILES.has(fileName);
+    // If the file is expected to contain decodable json, parse the contentStr
+    // first so Liquid inside JSON string values is validated after JSON unescapes
+    // string delimiters (e.g. \"Doc\" -> "Doc").
     const [content, jsonParseErrors] = decodable ? (0, _json.parseJson)(contentStr) : [
         contentStr,
         []
@@ -114,6 +118,18 @@ const readExtractedFileSync = (relpath, dirCtx, objPathToFieldStr = "")=>{
             error
         ];
     }
+    const liquidParseError = decodable ? validateLiquidSyntaxDeep(content) : (0, _liquid.validateLiquidSyntax)(contentStr);
+    if (liquidParseError) {
+        const error = new _error.JsonDataError(`points to a file that contains invalid liquid syntax (${relpath})\n\n` + (0, _error.formatErrors)([
+            liquidParseError
+        ], {
+            indentBy: 2
+        }), objPathToFieldStr);
+        return [
+            undefined,
+            error
+        ];
+    }
     return [
         content,
         undefined

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

@@ -0,0 +1,28 @@
+"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 formatMappingStatus () {
+        return formatMappingStatus;
+    },
+    get formatPreprocessScript () {
+        return formatPreprocessScript;
+    },
+    get formatSettingValue () {
+        return formatSettingValue;
+    }
+});
+const formatSettingValue = (value)=>{
+    if (value === undefined || value === null || value === "") return "-";
+    if (typeof value === "boolean") return value ? "Yes" : "No";
+    return String(value);
+};
+const formatPreprocessScript = (settings)=>settings.preprocess_script ? settings.preprocess_script.language : "-";
+const formatMappingStatus = (mapping)=>mapping.active ? "Active" : "Inactive";

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./helpers"), exports);
+_export_star(require("./types"), exports);
+function _export_star(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/source/types.js

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