@knocklabs/cli 0.1.4 → 0.1.5

package/dist/lib/api-v1.js

@@ -159,6 +159,53 @@ class ApiV1 {
             params
         });
     }
+    // By resources: Email layouts
+    async listEmailLayouts({ flags  }) {
+        const params = (0, _object.prune)({
+            environment: flags.environment,
+            annotate: flags.annotate,
+            hide_uncommitted_changes: flags["hide-uncommitted-changes"],
+            ...(0, _page.toPageParams)(flags)
+        });
+        return this.get("/email_layouts", {
+            params
+        });
+    }
+    async getEmailLayout({ args , flags  }) {
+        const params = (0, _object.prune)({
+            environment: flags.environment,
+            annotate: flags.annotate,
+            hide_uncommitted_changes: flags["hide-uncommitted-changes"]
+        });
+        return this.get(`/email_layouts/${args.emailLayoutKey}`, {
+            params
+        });
+    }
+    async upsertEmailLayout({ flags  }, layout) {
+        const params = (0, _object.prune)({
+            environment: flags.environment,
+            annotate: flags.annotate,
+            commit: flags.commit,
+            commit_message: flags["commit-message"]
+        });
+        const data = {
+            email_layout: layout
+        };
+        return this.put(`/email_layouts/${layout.key}`, data, {
+            params
+        });
+    }
+    async validateEmailLayout({ flags  }, layout) {
+        const params = (0, _object.prune)({
+            environment: flags.environment
+        });
+        const data = {
+            email_layout: layout
+        };
+        return this.put(`/email_layouts/${layout.key}/validate`, data, {
+            params
+        });
+    }
     // By methods:
     async get(subpath, config) {
         return this.client.get(`/${API_VERSION}` + subpath, config);

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

@@ -0,0 +1,124 @@
+"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, {
+    LAYOUT_JSON: ()=>LAYOUT_JSON,
+    emailLayoutJsonPath: ()=>emailLayoutJsonPath,
+    isEmailLayoutDir: ()=>isEmailLayoutDir,
+    lsEmailLayoutJson: ()=>lsEmailLayoutJson,
+    ensureValidCommandTarget: ()=>ensureValidCommandTarget
+});
+const _nodePath = /*#__PURE__*/ _interopRequireWildcard(require("node:path"));
+const _core = require("@oclif/core");
+const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
+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 _interopRequireWildcard(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 = {};
+    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 LAYOUT_JSON = "layout.json";
+const emailLayoutJsonPath = (layoutDirCtx)=>_nodePath.resolve(layoutDirCtx.abspath, LAYOUT_JSON);
+const isEmailLayoutDir = async (dirPath)=>Boolean(await lsEmailLayoutJson(dirPath));
+const lsEmailLayoutJson = async (dirPath)=>{
+    const emailLayoutJsonPath = _nodePath.resolve(dirPath, LAYOUT_JSON);
+    const exists = await _fsExtra.pathExists(emailLayoutJsonPath);
+    return exists ? emailLayoutJsonPath : undefined;
+};
+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 !== "email_layout") {
+        return _core.ux.error(`Cannot run ${commandId} inside a ${resourceDirCtx.type} directory`);
+    }
+    // Cannot accept both email layout key arg and --all flag.
+    if (flags.all && args.emailLayoutKey) {
+        return _core.ux.error(`emailLayoutKey arg \`${args.emailLayoutKey}\` cannot also be provided when using --all`);
+    }
+    // --all flag is given, which means no layout key arg.
+    if (flags.all) {
+        // If --all flag used inside a layout directory, then require a layouts dir path.
+        if (resourceDirCtx && !flags["layouts-dir"]) {
+            return _core.ux.error("Missing required flag layouts-dir");
+        }
+        // Targeting all layout dirs in the layouts index dir.
+        // TODO: Default to the knock project config first if present before cwd.
+        const defaultToCwd = {
+            abspath: runCwd,
+            exists: true
+        };
+        const indexDirCtx = flags["layouts-dir"] || defaultToCwd;
+        return {
+            type: "emailLayoutsIndexDir",
+            context: indexDirCtx
+        };
+    }
+    // Email layout key arg is given, which means no --all flag.
+    if (args.emailLayoutKey) {
+        if (resourceDirCtx && resourceDirCtx.key !== args.emailLayoutKey) {
+            return _core.ux.error(`Cannot run ${commandId} \`${args.emailLayoutKey}\` inside another layout directory:\n${resourceDirCtx.key}`);
+        }
+        const targetDirPath = resourceDirCtx ? resourceDirCtx.abspath : _nodePath.resolve(runCwd, args.emailLayoutKey);
+        const layoutDirCtx = {
+            type: "email_layout",
+            key: args.emailLayoutKey,
+            abspath: targetDirPath,
+            exists: await isEmailLayoutDir(targetDirPath)
+        };
+        return {
+            type: "emailLayoutDir",
+            context: layoutDirCtx
+        };
+    }
+    // From this point on, we have neither an email layout key arg nor --all flag.
+    // If running inside a layout directory, then use that.
+    if (resourceDirCtx) {
+        return {
+            type: "emailLayoutDir",
+            context: resourceDirCtx
+        };
+    }
+    return _core.ux.error("Missing 1 required arg:emailLayoutKey");
+};

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

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

@@ -0,0 +1,193 @@
+"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: ()=>readAllForCommandTarget,
+    readEmailLayoutDir: ()=>readEmailLayoutDir
+});
+const _nodePath = /*#__PURE__*/ _interopRequireDefault(require("node:path"));
+const _core = require("@oclif/core");
+const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
+const _lodash = require("lodash");
+const _error = require("../../helpers/error");
+const _json = require("../../helpers/json");
+const _object = require("../../helpers/object");
+const _helpers = require("../shared/helpers");
+const _helpers1 = require("./helpers");
+function _interopRequireDefault(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 _interopRequireWildcard(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 = {};
+    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 readAllForCommandTarget = async (target, opts = {})=>{
+    const { type: targetType , context: targetCtx  } = target;
+    if (!targetCtx.exists) {
+        const subject = targetType === "emailLayoutDir" ? "a layout directory at" : "layout directories in";
+        return _core.ux.error(`Cannot locate ${subject} \`${targetCtx.abspath}\``);
+    }
+    switch(targetType){
+        case "emailLayoutDir":
+            {
+                return readEmailLayoutsDirs([
+                    targetCtx
+                ], opts);
+            }
+        case "emailLayoutsIndexDir":
+            {
+                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 layoutDirCtx = {
+                        type: "email_layout",
+                        key: dirent.name,
+                        abspath,
+                        exists: await (0, _helpers1.isEmailLayoutDir)(abspath)
+                    };
+                    return layoutDirCtx;
+                });
+                const layoutDirCtxs = (await Promise.all(promises)).filter((layoutDirCtx)=>layoutDirCtx.exists);
+                return readEmailLayoutsDirs(layoutDirCtxs, opts);
+            }
+        default:
+            throw new Error(`Invalid layout command target: ${target}`);
+    }
+};
+/*
+ * For the given list of layout directory contexts, read each layout dir and
+ * return layout directory data.
+ */ const readEmailLayoutsDirs = async (layoutDirCtxs, opts = {})=>{
+    const layouts = [];
+    const errors = [];
+    for (const layoutDirCtx of layoutDirCtxs){
+        // eslint-disable-next-line no-await-in-loop
+        const [layout, readErrors] = await readEmailLayoutDir(layoutDirCtx, opts);
+        if (readErrors.length > 0) {
+            const layoutJsonPath = _nodePath.default.resolve(layoutDirCtx.abspath, _helpers1.LAYOUT_JSON);
+            const e = new _error.SourceError((0, _error.formatErrors)(readErrors), layoutJsonPath);
+            errors.push(e);
+            continue;
+        }
+        layouts.push({
+            ...layoutDirCtx,
+            content: layout
+        });
+    }
+    return [
+        layouts,
+        errors
+    ];
+};
+const readEmailLayoutDir = async (layoutDirCtx, opts = {})=>{
+    const { abspath  } = layoutDirCtx;
+    const { withExtractedFiles =false , withReadonlyField =false  } = opts;
+    const dirExists = await _fsExtra.pathExists(abspath);
+    if (!dirExists) throw new Error(`${abspath} does not exist`);
+    const layoutJsonPath = await (0, _helpers1.lsEmailLayoutJson)(abspath);
+    if (!layoutJsonPath) throw new Error(`${abspath} is not a layout directory`);
+    const result = await (0, _json.readJson)(layoutJsonPath);
+    if (!result[0]) return result;
+    let [layoutJson] = result;
+    layoutJson = withReadonlyField ? layoutJson : (0, _object.omitDeep)(layoutJson, [
+        "__readonly"
+    ]);
+    return withExtractedFiles ? joinExtractedFiles(layoutDirCtx, layoutJson) : [
+        layoutJson,
+        []
+    ];
+};
+/*
+ * Given a layout json object, compiles all referenced extracted files from it
+ * and returns the updated object with the extracted content joined and inlined.
+ */ const joinExtractedFiles = async (layoutDirCtx, layoutJson)=>{
+    // Tracks any errors encountered during traversal. Mutated in place.
+    const errors = [];
+    // Tracks each new valid extracted file path seen (rebased to be relative to
+    // layout.json) in the layout json node. Mutated in place, and used
+    // to validate the uniqueness of an extracted path encountered.
+    const uniqueFilePaths = {};
+    (0, _object.mapValuesDeep)(layoutJson, (relpath, key, parts)=>{
+        // If not marked with the @suffix, there's nothing to do.
+        if (!_helpers.FILEPATH_MARKED_RE.test(key)) return;
+        const objPathToFieldStr = _object.ObjPath.stringify(parts);
+        const inlinObjPathStr = objPathToFieldStr.replace(_helpers.FILEPATH_MARKED_RE, "");
+        // If there is inlined content present already, then nothing more to do.
+        if ((0, _lodash.hasIn)(layoutJson, inlinObjPathStr)) return;
+        // Check if the extracted path found at the current field path is valid
+        const invalidFilePathError = (0, _helpers.validateExtractedFilePath)(relpath, _nodePath.default.resolve(layoutDirCtx.abspath, _helpers1.LAYOUT_JSON), uniqueFilePaths, objPathToFieldStr);
+        if (invalidFilePathError) {
+            errors.push(invalidFilePathError);
+            // Wipe the invalid file path in the node so the final layout json
+            // object ends up with only valid file paths, this way layout writer
+            // can see only valid file paths and use those when pulling.
+            (0, _lodash.set)(layoutJson, inlinObjPathStr, undefined);
+            (0, _lodash.set)(layoutJson, 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, layoutDirCtx, 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 layout object with empty content, so we know
+            // we do not need to try inlining again.
+            (0, _lodash.set)(layoutJson, objPathToFieldStr, relpath);
+            (0, _lodash.set)(layoutJson, inlinObjPathStr, undefined);
+            return;
+        }
+        // Inline the file content and remove the extracted file path.
+        (0, _lodash.set)(layoutJson, objPathToFieldStr, relpath);
+        (0, _lodash.set)(layoutJson, inlinObjPathStr, content);
+    });
+    return [
+        layoutJson,
+        errors
+    ];
+};

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

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

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

@@ -0,0 +1,240 @@
+"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, {
+    writeEmailLayoutDirFromData: ()=>writeEmailLayoutDirFromData,
+    writeEmailLayoutIndexDir: ()=>writeEmailLayoutIndexDir,
+    buildEmailLayoutDirBundle: ()=>buildEmailLayoutDirBundle,
+    pruneLayoutsIndexDir: ()=>pruneLayoutsIndexDir,
+    toEmailLayoutJson: ()=>toEmailLayoutJson
+});
+const _nodePath = /*#__PURE__*/ _interopRequireDefault(require("node:path"));
+const _fsExtra = /*#__PURE__*/ _interopRequireWildcard(require("fs-extra"));
+const _lodash = require("lodash");
+const _const = require("../../helpers/const");
+const _json = require("../../helpers/json");
+const _object = require("../../helpers/object");
+const _helpers = require("../shared/helpers");
+const _helpers1 = require("./helpers");
+const _reader = require("./reader");
+function _interopRequireDefault(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 _interopRequireWildcard(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 = {};
+    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;
+}
+/* Traverse a given email layout data and compile extraction settings of every extractable
+ * field into a sorted map.
+ *
+ * NOTE: Currently we do NOT support content extraction at nested levels for email layouts.
+ */ const compileExtractionSettings = (emailLayout)=>{
+    const extractableFields = (0, _lodash.get)(emailLayout, [
+        "__annotation",
+        "extractable_fields"
+    ], {});
+    const map = new Map();
+    for (const [key] of Object.entries(emailLayout)){
+        // 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;
+};
+/* Sanitize the email layout content into a format that's appropriate for reading
+ * and writing, by stripping out any annotation fields and handling readonly
+ * fields.
+ */ const toEmailLayoutJson = (emailLayout)=>{
+    var _emailLayout___annotation;
+    // Move read only field under the dedicated field "__readonly".
+    const readonlyFields = ((_emailLayout___annotation = emailLayout.__annotation) === null || _emailLayout___annotation === void 0 ? void 0 : _emailLayout___annotation.readonly_fields) || [];
+    const [readonly, remainder] = (0, _object.split)(emailLayout, readonlyFields);
+    const emailLayoutjson = {
+        ...remainder,
+        __readonly: readonly
+    };
+    // Strip out all schema annotations, so not to expose them to end users.
+    return (0, _object.omitDeep)(emailLayoutjson, [
+        "__annotation"
+    ]);
+};
+const writeEmailLayoutDirFromData = async (emailLayoutDirCtx, remoteEmailLayout)=>{
+    // If the layout directory exists on the file system (i.e. previously
+    // pulled before), then read the layout file to use as a reference.
+    const [localEmailLayout] = emailLayoutDirCtx.exists ? await (0, _reader.readEmailLayoutDir)(emailLayoutDirCtx, {
+        withExtractedFiles: true
+    }) : [];
+    const bundle = buildEmailLayoutDirBundle(remoteEmailLayout, localEmailLayout);
+    const backupDirPath = _nodePath.default.resolve(_const.sandboxDir, (0, _lodash.uniqueId)("backup"));
+    try {
+        // We store a backup in case there's an error.
+        if (emailLayoutDirCtx.exists) {
+            await _fsExtra.copy(emailLayoutDirCtx.abspath, backupDirPath);
+            await _fsExtra.emptyDir(emailLayoutDirCtx.abspath);
+        }
+        const promises = Object.entries(bundle).map(([relpath, fileContent])=>{
+            const filePath = _nodePath.default.resolve(emailLayoutDirCtx.abspath, relpath);
+            return relpath === _helpers1.LAYOUT_JSON ? _fsExtra.outputJson(filePath, fileContent, {
+                spaces: _json.DOUBLE_SPACES
+            }) : _fsExtra.outputFile(filePath, 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 (emailLayoutDirCtx.exists) {
+            await _fsExtra.emptyDir(emailLayoutDirCtx.abspath);
+            await _fsExtra.copy(backupDirPath, emailLayoutDirCtx.abspath);
+        } else {
+            await _fsExtra.remove(emailLayoutDirCtx.abspath);
+        }
+        throw error;
+    } finally{
+        // Always clean up the backup directory in the temp sandbox.
+        await _fsExtra.remove(backupDirPath);
+    }
+};
+/* For a given email layout payload, this function builds a "email layout directoy bundle".
+ * This is an object which contains all the relative paths and its file content.
+ * It includes the extractable fields, which are extracted out and added to the bundle as separate files.
+ */ const buildEmailLayoutDirBundle = (remoteEmailLayout, localEmailLayout = {})=>{
+    const bundle = {};
+    const mutRemoteEmailLayout = (0, _lodash.cloneDeep)(remoteEmailLayout);
+    // A map of extraction settings of every field in the email layout
+    const compiledExtractionSettings = compileExtractionSettings(mutRemoteEmailLayout);
+    // 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 layout doesn't have this field path, then we don't extract.
+        if (!(0, _lodash.has)(mutRemoteEmailLayout, objPathParts)) continue;
+        // If the field at this path is extracted in the local layout, then
+        // always extract; otherwise extract based on the field settings default.
+        const objPathStr = _object.ObjPath.stringify(objPathParts);
+        const extractedFilePath = (0, _lodash.get)(localEmailLayout, `${objPathStr}${_helpers.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)(mutRemoteEmailLayout, objPathParts);
+        const fileName = objPathParts.pop();
+        // If we have an extracted file path from the local layout, 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)(mutRemoteEmailLayout, `${objPathStr}${_helpers.FILEPATH_MARKER}`, relpath);
+        (0, _lodash.unset)(mutRemoteEmailLayout, objPathStr);
+    }
+    // At this point the bundle contains all extractable files, so we finally add the layout
+    // JSON realtive path + the file content.
+    return (0, _lodash.set)(bundle, [
+        _helpers1.LAYOUT_JSON
+    ], toEmailLayoutJson(mutRemoteEmailLayout));
+};
+const writeEmailLayoutIndexDir = async (indexDirCtx, remoteEmailLayouts)=>{
+    const backupDirPath = _nodePath.default.resolve(_const.sandboxDir, (0, _lodash.uniqueId)("backup"));
+    try {
+        if (indexDirCtx.exists) {
+            await _fsExtra.copy(indexDirCtx.abspath, backupDirPath);
+            await pruneLayoutsIndexDir(indexDirCtx, remoteEmailLayouts);
+        }
+        const writeEmailLayoutDirPromises = remoteEmailLayouts.map(async (remoteEmailLayout)=>{
+            const emailLayoutDirPath = _nodePath.default.resolve(indexDirCtx.abspath, remoteEmailLayout.key);
+            const emailLayoutDirCtx = {
+                type: "email_layout",
+                key: remoteEmailLayout.key,
+                abspath: emailLayoutDirPath,
+                exists: indexDirCtx.exists ? await (0, _helpers1.isEmailLayoutDir)(emailLayoutDirPath) : false
+            };
+            return writeEmailLayoutDirFromData(emailLayoutDirCtx, remoteEmailLayout);
+        });
+        await Promise.all(writeEmailLayoutDirPromises);
+    } catch (error) {
+        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);
+    }
+};
+/*
+ * Prunes the index directory by removing any files, or directories that aren't
+ * layout dirs found in fetched layouts. We want to preserve any layout
+ * dirs that are going to be updated with remote layouts, so extracted links
+ * can be respected.
+ */ const pruneLayoutsIndexDir = async (indexDirCtx, remoteEmailLayouts)=>{
+    const emailLayoutsByKey = Object.fromEntries(remoteEmailLayouts.map((e)=>[
+            e.key.toLowerCase(),
+            e
+        ]));
+    const dirents = await _fsExtra.readdir(indexDirCtx.abspath, {
+        withFileTypes: true
+    });
+    const promises = dirents.map(async (dirent)=>{
+        const direntName = dirent.name.toLowerCase();
+        const direntPath = _nodePath.default.resolve(indexDirCtx.abspath, direntName);
+        if (await (0, _helpers1.isEmailLayoutDir)(direntPath) && emailLayoutsByKey[direntName]) {
+            return;
+        }
+        await _fsExtra.remove(direntPath);
+    });
+    await Promise.all(promises);
+};