@knocklabs/cli 0.1.17 → 0.1.19

package/dist/lib/marshal/message-type/processor.isomorphic.js

@@ -0,0 +1,78 @@
+"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, {
+    MESSAGE_TYPE_JSON: function() {
+        return MESSAGE_TYPE_JSON;
+    },
+    buildMessageTypeDirBundle: function() {
+        return buildMessageTypeDirBundle;
+    }
+});
+const _lodash = require("lodash");
+const _objectisomorphic = require("../../helpers/object.isomorphic");
+const _constisomorphic = require("../shared/const.isomorphic");
+const _helpersisomorphic = require("../shared/helpers.isomorphic");
+const MESSAGE_TYPE_JSON = "message_type.json";
+const compileExtractionSettings = (messageType)=>{
+    const extractableFields = (0, _lodash.get)(messageType, [
+        "__annotation",
+        "extractable_fields"
+    ], {});
+    const map = new Map();
+    for (const [key] of Object.entries(messageType)){
+        // If the field we are on is extractable, then add its extraction settings
+        // to the map with the current object path.
+        if (key in extractableFields) {
+            map.set([
+                key
+            ], extractableFields[key]);
+        }
+    }
+    return map;
+};
+const buildMessageTypeDirBundle = (remoteMessageType, localMessageType = {})=>{
+    const bundle = {};
+    const mutRemoteMessageType = (0, _lodash.cloneDeep)(remoteMessageType);
+    // A map of extraction settings of every field in the message type
+    const compiledExtractionSettings = compileExtractionSettings(mutRemoteMessageType);
+    // Iterate through each extractable field, determine whether we need to
+    // extract the field content, and if so, perform the extraction.
+    for (const [objPathParts, extractionSettings] of compiledExtractionSettings){
+        // If this message type doesn't have this field path, then we don't extract.
+        if (!(0, _lodash.has)(mutRemoteMessageType, objPathParts)) continue;
+        // If the field at this path is extracted in the local message type, then
+        // always extract; otherwise extract based on the field settings default.
+        const objPathStr = _objectisomorphic.ObjPath.stringify(objPathParts);
+        const extractedFilePath = (0, _lodash.get)(localMessageType, `${objPathStr}${_constisomorphic.FILEPATH_MARKER}`);
+        const { default: extractByDefault, file_ext: fileExt } = extractionSettings;
+        if (!extractedFilePath && !extractByDefault) continue;
+        // By this point, we have a field where we need to extract its content.
+        const data = (0, _lodash.get)(mutRemoteMessageType, objPathParts);
+        const fileName = objPathParts.pop();
+        // If we have an extracted file path from the local message type, we use
+        // that.  In the other case we use the default path.
+        const relpath = typeof extractedFilePath === "string" ? extractedFilePath : `${fileName}.${fileExt}`;
+        // Perform the extraction by adding the content and its file path to the
+        // bundle for writing to the file system later. Then replace the field
+        // content with the extracted file path and mark the field as extracted
+        // with @ suffix.
+        (0, _lodash.set)(bundle, [
+            relpath
+        ], data);
+        (0, _lodash.set)(mutRemoteMessageType, `${objPathStr}${_constisomorphic.FILEPATH_MARKER}`, relpath);
+        (0, _lodash.unset)(mutRemoteMessageType, objPathStr);
+    }
+    // At this point the bundle contains all extractable files, so we finally add
+    // the message type JSON relative path + the file content.
+    return (0, _lodash.set)(bundle, [
+        MESSAGE_TYPE_JSON
+    ], (0, _helpersisomorphic.prepareResourceJson)(mutRemoteMessageType));
+};

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

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

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

@@ -0,0 +1,134 @@
+"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, {
+    ensureValidCommandTarget: function() {
+        return ensureValidCommandTarget;
+    },
+    isPartialDir: function() {
+        return isPartialDir;
+    },
+    lsPartialJson: function() {
+        return lsPartialJson;
+    },
+    partialJsonPath: function() {
+        return partialJsonPath;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+const _core = require("@oclif/core");
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+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 partialJsonPath = (partialDirCtx)=>_nodepath.resolve(partialDirCtx.abspath, _processorisomorphic.PARTIAL_JSON);
+const lsPartialJson = async (dirPath)=>{
+    const partialJsonPath = _nodepath.resolve(dirPath, _processorisomorphic.PARTIAL_JSON);
+    const exists = await _fsextra.pathExists(partialJsonPath);
+    return exists ? partialJsonPath : undefined;
+};
+const isPartialDir = async (dirPath)=>Boolean(await lsPartialJson(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 !== "partial") {
+        return _core.ux.error(`Cannot run ${commandId} inside a ${resourceDirCtx.type} directory`);
+    }
+    // Cannot accept both partial key arg and --all flag.
+    if (flags.all && args.partialKey) {
+        return _core.ux.error(`partialKey arg \`${args.partialKey}\` cannot also be provided when using --all`);
+    }
+    // --all flag is given, which means no partial key arg.
+    if (flags.all) {
+        // If --all flag used inside a partial directory, then require a partials
+        // dir path.
+        if (resourceDirCtx && !flags["partials-dir"]) {
+            return _core.ux.error("Missing required flag partials-dir");
+        }
+        // Targeting all partial dirs in the partials index dir.
+        // TODO: Default to the knock project config first if present before cwd.
+        const defaultToCwd = {
+            abspath: runCwd,
+            exists: true
+        };
+        const indexDirCtx = flags["partials-dir"] || defaultToCwd;
+        return {
+            type: "partialsIndexDir",
+            context: indexDirCtx
+        };
+    }
+    // Partial key arg is given, which means no --all flag.
+    if (args.partialKey) {
+        if (resourceDirCtx && resourceDirCtx.key !== args.partialKey) {
+            return _core.ux.error(`Cannot run ${commandId} \`${args.partialKey}\` inside another partial directory:\n${resourceDirCtx.key}`);
+        }
+        const targetDirPath = resourceDirCtx ? resourceDirCtx.abspath : _nodepath.resolve(runCwd, args.partialKey);
+        const partialDirCtx = {
+            type: "partial",
+            key: args.partialKey,
+            abspath: targetDirPath,
+            exists: await isPartialDir(targetDirPath)
+        };
+        return {
+            type: "partialDir",
+            context: partialDirCtx
+        };
+    }
+    // From this point on, we have neither a partial key arg nor --all flag.
+    // If running inside a partial directory, then use that partial directory.
+    if (resourceDirCtx) {
+        return {
+            type: "partialDir",
+            context: resourceDirCtx
+        };
+    }
+    return _core.ux.error("Missing 1 required arg:\npartialKey");
+};

package/dist/lib/marshal/partial/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/partial/processor.isomorphic.js

@@ -14,34 +14,14 @@ _export(exports, {
     },
     buildPartialDirBundle: function() {
         return buildPartialDirBundle;
-    },
-    toPartialJson: function() {
-        return toPartialJson;
     }
 });
 const _lodash = require("lodash");
 const _objectisomorphic = require("../../helpers/object.isomorphic");
 const _constisomorphic = require("../shared/const.isomorphic");
+const _helpersisomorphic = require("../shared/helpers.isomorphic");
 const _types = require("./types");
 const PARTIAL_JSON = "partial.json";
-/*
- * Sanitize the partial content into a format that's appropriate for reading
- * and writing, by stripping out any annotation fields and handling readonly
- * fields.
- */ const toPartialJson = (partial)=>{
-    var _partial___annotation;
-    // Move read only field under the dedicated field "__readonly".
-    const readonlyFields = ((_partial___annotation = partial.__annotation) === null || _partial___annotation === void 0 ? void 0 : _partial___annotation.readonly_fields) || [];
-    const [readonly, remainder] = (0, _objectisomorphic.split)(partial, readonlyFields);
-    const partialjson = {
-        ...remainder,
-        __readonly: readonly
-    };
-    // Strip out all schema annotations, so not to expose them to end users.
-    return (0, _objectisomorphic.omitDeep)(partialjson, [
-        "__annotation"
-    ]);
-};
 // Maps the partial type to the correct file extension. Defaults to 'txt'
 const partialTypeToFileExt = (type)=>{
     switch(type){
@@ -87,8 +67,7 @@ const buildPartialDirBundle = (remotePartial, localPartial = {})=>{
     // A map of extraction settings of every field in the partial
     const compiledExtractionSettings = compileExtractionSettings(mutRemotePartial);
     // Iterate through each extractable field, determine whether we need to
-    // extract the field content, and if so, perform the
-    // extraction.
+    // extract the field content, and if so, perform the extraction.
     for (const [objPathParts, extractionSettings] of compiledExtractionSettings){
         // If this partial doesn't have this field path, then we don't extract.
         if (!(0, _lodash.has)(mutRemotePartial, objPathParts)) continue;
@@ -118,5 +97,5 @@ const buildPartialDirBundle = (remotePartial, localPartial = {})=>{
     // the partial JSON relative path + the file content.
     return (0, _lodash.set)(bundle, [
         PARTIAL_JSON
-    ], toPartialJson(mutRemotePartial));
+    ], (0, _helpersisomorphic.prepareResourceJson)(mutRemotePartial));
 };

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

@@ -0,0 +1,198 @@
+"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, {
+    readAllForCommandTarget: function() {
+        return readAllForCommandTarget;
+    },
+    readPartialDir: function() {
+        return readPartialDir;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _core = require("@oclif/core");
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _lodash = require("lodash");
+const _error = require("../../helpers/error");
+const _json = require("../../helpers/json");
+const _objectisomorphic = require("../../helpers/object.isomorphic");
+const _helpers = require("../shared/helpers");
+const _constisomorphic = require("../shared/const.isomorphic");
+const _helpers1 = require("./helpers");
+const _processorisomorphic = require("./processor.isomorphic");
+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;
+}
+/*
+ * For the given list of partial directory contexts, read each partial dir and
+ * return partial directory data.
+ */ const readPartialsDirs = async (partialDirCtxs, opts = {})=>{
+    const partials = [];
+    const errors = [];
+    for (const partialDirCtx of partialDirCtxs){
+        // eslint-disable-next-line no-await-in-loop
+        const [partial, readErrors] = await readPartialDir(partialDirCtx, opts);
+        if (readErrors.length > 0) {
+            const partialJsonPath = _nodepath.default.resolve(partialDirCtx.abspath, _processorisomorphic.PARTIAL_JSON);
+            const e = new _error.SourceError((0, _error.formatErrors)(readErrors), partialJsonPath);
+            errors.push(e);
+            continue;
+        }
+        partials.push({
+            ...partialDirCtx,
+            content: partial
+        });
+    }
+    return [
+        partials,
+        errors
+    ];
+};
+const readPartialDir = async (partialDirCtx, opts = {})=>{
+    const { abspath } = partialDirCtx;
+    const { withExtractedFiles = false, withReadonlyField = false } = opts;
+    const dirExists = await _fsextra.pathExists(abspath);
+    if (!dirExists) throw new Error(`${abspath} does not exist`);
+    const partialJsonPath = await (0, _helpers1.lsPartialJson)(abspath);
+    if (!partialJsonPath) throw new Error(`${abspath} is not a partial directory`);
+    const result = await (0, _json.readJson)(partialJsonPath);
+    if (!result[0]) return result;
+    let [partialJson] = result;
+    partialJson = withReadonlyField ? partialJson : (0, _objectisomorphic.omitDeep)(partialJson, [
+        "__readonly"
+    ]);
+    return withExtractedFiles ? joinExtractedFiles(partialDirCtx, partialJson) : [
+        partialJson,
+        []
+    ];
+};
+const joinExtractedFiles = async (partialDirCtx, partialJson)=>{
+    // Tracks any errors encountered during traversal. Mutated in place.
+    const errors = [];
+    // Tracks each new valid extracted file path seen (rebased to be relative to
+    // partial.json) in the partial json node. Mutated in place, and used
+    // to validate the uniqueness of an extracted path encountered.
+    const uniqueFilePaths = {};
+    (0, _objectisomorphic.mapValuesDeep)(partialJson, (relpath, key, parts)=>{
+        // If not marked with the @suffix, there's nothing to do.
+        if (!_constisomorphic.FILEPATH_MARKED_RE.test(key)) return;
+        const objPathToFieldStr = _objectisomorphic.ObjPath.stringify(parts);
+        const inlinObjPathStr = objPathToFieldStr.replace(_constisomorphic.FILEPATH_MARKED_RE, "");
+        // If there is inlined content present already, then nothing more to do.
+        if ((0, _lodash.hasIn)(partialJson, inlinObjPathStr)) return;
+        // Check if the extracted path found at the current field path is valid
+        const invalidFilePathError = (0, _helpers.validateExtractedFilePath)(relpath, _nodepath.default.resolve(partialDirCtx.abspath, _processorisomorphic.PARTIAL_JSON), uniqueFilePaths, objPathToFieldStr);
+        if (invalidFilePathError) {
+            errors.push(invalidFilePathError);
+            // Wipe the invalid file path in the node so the final partial json
+            // object ends up with only valid file paths, this way partial writer
+            // can see only valid file paths and use those when pulling.
+            (0, _lodash.set)(partialJson, inlinObjPathStr, undefined);
+            (0, _lodash.set)(partialJson, objPathToFieldStr, undefined);
+            return;
+        }
+        // By this point we have a valid extracted file path, so attempt to read the file.
+        const [content, readExtractedFileError] = (0, _helpers.readExtractedFileSync)(relpath, partialDirCtx, key);
+        if (readExtractedFileError) {
+            errors.push(readExtractedFileError);
+            // If there's an error, replace the extracted file path with the original one, and set the
+            // inlined field path in partial object with empty content, so we know
+            // we do not need to try inlining again.
+            (0, _lodash.set)(partialJson, objPathToFieldStr, relpath);
+            (0, _lodash.set)(partialJson, inlinObjPathStr, undefined);
+            return;
+        }
+        // Inline the file content and remove the extracted file path.
+        (0, _lodash.set)(partialJson, objPathToFieldStr, relpath);
+        (0, _lodash.set)(partialJson, inlinObjPathStr, content);
+    });
+    return [
+        partialJson,
+        errors
+    ];
+};
+const readAllForCommandTarget = async (target, opts = {})=>{
+    const { type: targetType, context: targetCtx } = target;
+    if (!targetCtx.exists) {
+        const subject = targetType === "partialDir" ? "a partial directory at" : "partial directories in";
+        return _core.ux.error(`Cannot locate ${subject} \`${targetCtx.abspath}\``);
+    }
+    switch(targetType){
+        case "partialDir":
+            {
+                return readPartialsDirs([
+                    targetCtx
+                ], opts);
+            }
+        case "partialsIndexDir":
+            {
+                const dirents = await _fsextra.readdir(targetCtx.abspath, {
+                    withFileTypes: true
+                });
+                const promises = dirents.map(async (dirent)=>{
+                    const abspath = _nodepath.default.resolve(targetCtx.abspath, dirent.name);
+                    const partialDirCtx = {
+                        type: "partial",
+                        key: dirent.name,
+                        abspath,
+                        exists: await (0, _helpers1.isPartialDir)(abspath)
+                    };
+                    return partialDirCtx;
+                });
+                const partialDirCtxs = (await Promise.all(promises)).filter((partialDirCtx)=>partialDirCtx.exists);
+                return readPartialsDirs(partialDirCtxs, opts);
+            }
+        default:
+            throw new Error(`Invalid partial command target: ${target}`);
+    }
+};

package/dist/lib/marshal/partial/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, {
+    prunePartialsIndexDir: function() {
+        return prunePartialsIndexDir;
+    },
+    writePartialDirFromData: function() {
+        return writePartialDirFromData;
+    },
+    writePartialsIndexDir: function() {
+        return writePartialsIndexDir;
+    }
+});
+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 writePartialDirFromData = async (partialDirCtx, remotePartial)=>{
+    // If the partial directory exists on the file system (i.e. previously
+    // pulled before), then read the partial file to use as a reference.
+    const [localPartial] = partialDirCtx.exists ? await (0, _reader.readPartialDir)(partialDirCtx, {
+        withExtractedFiles: true
+    }) : [];
+    const bundle = (0, _processorisomorphic.buildPartialDirBundle)(remotePartial, localPartial);
+    return writePartialDirFromBundle(partialDirCtx, bundle);
+};
+/*
+ * A lower level write function that takes a constructed partial dir bundle
+ * and writes it into a partial directory on a local file system.
+ *
+ * It does not make any assumptions about how the partial directory bundle was
+ * built; for example, it can be from parsing the partial data fetched from
+ * the Knock API, or built manually for scaffolding purposes.
+ */ const writePartialDirFromBundle = async (partialDirCtx, partialDirBundle)=>{
+    const backupDirPath = _nodepath.resolve(_const.sandboxDir, (0, _lodash.uniqueId)("backup"));
+    try {
+        if (partialDirCtx.exists) {
+            await _fsextra.copy(partialDirCtx.abspath, backupDirPath);
+            await _fsextra.emptyDir(partialDirCtx.abspath);
+        }
+        const promises = Object.entries(partialDirBundle).map(([relpath, fileContent])=>{
+            const filePath = _nodepath.resolve(partialDirCtx.abspath, relpath);
+            return relpath === _processorisomorphic.PARTIAL_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 (partialDirCtx.exists) {
+            await _fsextra.emptyDir(partialDirCtx.abspath);
+            await _fsextra.copy(backupDirPath, partialDirCtx.abspath);
+        } else {
+            await _fsextra.remove(partialDirCtx.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
+ * partial dirs found in fetched partials. We want to preserve any partial
+ * dirs that are going to be updated with remote partials, so extracted links
+ * can be respected.
+ */ const prunePartialsIndexDir = async (indexDirCtx, remotePartials)=>{
+    const partialsByKey = Object.fromEntries(remotePartials.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.isPartialDir)(direntPath) && partialsByKey[direntName]) {
+            return;
+        }
+        await _fsextra.remove(direntPath);
+    });
+    await Promise.all(promises);
+};
+const writePartialsIndexDir = async (indexDirCtx, remotePartials)=>{
+    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 prunePartialsIndexDir(indexDirCtx, remotePartials);
+        }
+        // Write given remote partials into the given partials directory path.
+        const writePartialDirPromises = remotePartials.map(async (partial)=>{
+            const partialDirPath = _nodepath.resolve(indexDirCtx.abspath, partial.key);
+            const partialDirCtx = {
+                type: "partial",
+                key: partial.key,
+                abspath: partialDirPath,
+                exists: indexDirCtx.exists ? await (0, _helpers.isPartialDir)(partialDirPath) : false
+            };
+            return writePartialDirFromData(partialDirCtx, partial);
+        });
+        await Promise.all(writePartialDirPromises);
+    } 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/shared/helpers.isomorphic.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "prepareResourceJson", {
+    enumerable: true,
+    get: function() {
+        return prepareResourceJson;
+    }
+});
+const _objectisomorphic = require("../../helpers/object.isomorphic");
+const prepareResourceJson = (resource)=>{
+    var _resource___annotation;
+    // Move read only field under the dedicated field "__readonly".
+    const readonlyFields = ((_resource___annotation = resource.__annotation) === null || _resource___annotation === void 0 ? void 0 : _resource___annotation.readonly_fields) || [];
+    const [readonly, remainder] = (0, _objectisomorphic.split)(resource, readonlyFields);
+    const resourceJson = {
+        ...remainder,
+        __readonly: readonly
+    };
+    // Strip out all schema annotations, so not to expose them to end users.
+    return (0, _objectisomorphic.omitDeep)(resourceJson, [
+        "__annotation"
+    ]);
+};