@knocklabs/cli 0.1.22 → 0.2.0

package/dist/lib/marshal/guide/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: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get readAllForCommandTarget () {
+        return readAllForCommandTarget;
+    },
+    get readGuideDir () {
+        return readGuideDir;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+const _core = require("@oclif/core");
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _lodash = require("lodash");
+const _error = require("../../helpers/error");
+const _json = require("../../helpers/json");
+const _objectisomorphic = require("../../helpers/object.isomorphic");
+const _constisomorphic = require("../shared/const.isomorphic");
+const _helpers = require("../shared/helpers");
+const _helpers1 = require("./helpers");
+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;
+}
+/*
+ * For the given list of guide directory contexts, read each guide dir and
+ * return guide directory data.
+ */ const readGuideDirs = async (guideDirCtxs, opts = {})=>{
+    const guides = [];
+    const errors = [];
+    for (const guideDirCtx of guideDirCtxs){
+        // eslint-disable-next-line no-await-in-loop
+        const [guide, readErrors] = await readGuideDir(guideDirCtx, opts);
+        if (readErrors.length > 0) {
+            const guideJsonPath = _nodepath.resolve(guideDirCtx.abspath, _processorisomorphic.GUIDE_JSON);
+            const e = new _error.SourceError((0, _error.formatErrors)(readErrors), guideJsonPath);
+            errors.push(e);
+            continue;
+        }
+        guides.push({
+            ...guideDirCtx,
+            content: guide
+        });
+    }
+    return [
+        guides,
+        errors
+    ];
+};
+const readGuideDir = async (guideDirCtx, opts = {})=>{
+    const { abspath } = guideDirCtx;
+    const { withExtractedFiles = false } = opts;
+    const dirExists = await _fsextra.pathExists(abspath);
+    if (!dirExists) throw new Error(`${abspath} does not exist`);
+    const guideJsonPath = await (0, _helpers1.lsGuideJson)(abspath);
+    if (!guideJsonPath) throw new Error(`${abspath} is not a guide directory`);
+    const result = await (0, _json.readJson)(guideJsonPath);
+    if (!result[0]) return result;
+    let [guideJson] = result;
+    guideJson = (0, _objectisomorphic.omitDeep)(guideJson, [
+        "__readonly"
+    ]);
+    return withExtractedFiles ? joinExtractedFiles(guideDirCtx, guideJson) : [
+        guideJson,
+        []
+    ];
+};
+const joinExtractedFiles = async (guideDirCtx, guideJson)=>{
+    // Tracks any errors encountered during traversal. Mutated in place.
+    const errors = [];
+    // Tracks each new valid extracted file path seen (rebased to be relative to
+    // guide.json) in the guide json node. Mutated in place, and used
+    // to validate the uniqueness of an extracted path encountered.
+    const uniqueFilePaths = {};
+    (0, _objectisomorphic.mapValuesDeep)(guideJson, (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)(guideJson, inlinObjPathStr)) return;
+        // Check if the extracted path found at the current field path is valid
+        const invalidFilePathError = (0, _helpers.validateExtractedFilePath)(relpath, _nodepath.resolve(guideDirCtx.abspath, _processorisomorphic.GUIDE_JSON), uniqueFilePaths, objPathToFieldStr);
+        if (invalidFilePathError) {
+            errors.push(invalidFilePathError);
+            // Wipe the invalid file path in the node so the final guide json
+            // object ends up with only valid file paths, this way guide writer
+            // can see only valid file paths and use those when pulling.
+            (0, _lodash.set)(guideJson, inlinObjPathStr, undefined);
+            (0, _lodash.set)(guideJson, 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, guideDirCtx, 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 guide object with empty content, so we know
+            // we do not need to try inlining again.
+            (0, _lodash.set)(guideJson, objPathToFieldStr, relpath);
+            (0, _lodash.set)(guideJson, inlinObjPathStr, undefined);
+            return;
+        }
+        // Inline the file content and remove the extracted file path.
+        (0, _lodash.set)(guideJson, objPathToFieldStr, relpath);
+        (0, _lodash.set)(guideJson, inlinObjPathStr, content);
+    });
+    return [
+        guideJson,
+        errors
+    ];
+};
+const readAllForCommandTarget = async (target, opts = {})=>{
+    const { type: targetType, context: targetCtx } = target;
+    if (!targetCtx.exists) {
+        const subject = targetType === "guideDir" ? "a guide directory at" : "guide directories in";
+        return _core.ux.error(`Cannot locate ${subject} \`${targetCtx.abspath}\``);
+    }
+    switch(targetType){
+        case "guideDir":
+            {
+                return readGuideDirs([
+                    targetCtx
+                ], opts);
+            }
+        case "guidesIndexDir":
+            {
+                const dirents = await _fsextra.readdir(targetCtx.abspath, {
+                    withFileTypes: true
+                });
+                const promises = dirents.map(async (dirent)=>{
+                    const abspath = _nodepath.resolve(targetCtx.abspath, dirent.name);
+                    const guideDirCtx = {
+                        type: "guide",
+                        key: dirent.name,
+                        abspath,
+                        exists: await (0, _helpers1.isGuideDir)(abspath)
+                    };
+                    return guideDirCtx;
+                });
+                const guideDirCtxs = (await Promise.all(promises)).filter((guideDirCtx)=>guideDirCtx.exists);
+                return readGuideDirs(guideDirCtxs, opts);
+            }
+        default:
+            throw new Error(`Invalid guide command target: ${target}`);
+    }
+};

package/dist/lib/marshal/guide/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: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get pruneGuidesIndexDir () {
+        return pruneGuidesIndexDir;
+    },
+    get writeGuideDirFromData () {
+        return writeGuideDirFromData;
+    },
+    get writeGuidesIndexDir () {
+        return writeGuidesIndexDir;
+    }
+});
+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 writeGuideDirFromData = async (guideDirCtx, remoteGuide)=>{
+    // If the guide directory exists on the file system (i.e. previously
+    // pulled before), then read the guide file to use as a reference.
+    const [localGuide] = guideDirCtx.exists ? await (0, _reader.readGuideDir)(guideDirCtx, {
+        withExtractedFiles: true
+    }) : [];
+    const bundle = (0, _processorisomorphic.buildGuideDirBundle)(remoteGuide, localGuide);
+    return writeGuideDirFromBundle(guideDirCtx, bundle);
+};
+/*
+ * A lower level write function that takes a constructed guide dir bundle
+ * and writes it into a guide directory on a local file system.
+ *
+ * It does not make any assumptions about how the guide directory bundle was
+ * built; for example, it can be from parsing the guide data fetched from
+ * the Knock API, or built manually for scaffolding purposes.
+ */ const writeGuideDirFromBundle = async (guideDirCtx, guideDirBundle)=>{
+    const backupDirPath = _nodepath.resolve(_const.sandboxDir, (0, _lodash.uniqueId)("backup"));
+    try {
+        if (guideDirCtx.exists) {
+            await _fsextra.copy(guideDirCtx.abspath, backupDirPath);
+            await _fsextra.emptyDir(guideDirCtx.abspath);
+        }
+        const promises = Object.entries(guideDirBundle).map(([relpath, fileContent])=>{
+            const filePath = _nodepath.resolve(guideDirCtx.abspath, relpath);
+            return relpath === _processorisomorphic.GUIDE_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 (guideDirCtx.exists) {
+            await _fsextra.emptyDir(guideDirCtx.abspath);
+            await _fsextra.copy(backupDirPath, guideDirCtx.abspath);
+        } else {
+            await _fsextra.remove(guideDirCtx.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
+ * guide dirs found in fetched guides. We want to preserve any guide
+ * dirs that are going to be updated with remote guides, so extracted links
+ * can be respected.
+ */ const pruneGuidesIndexDir = async (indexDirCtx, remoteGuides)=>{
+    const guidesByKey = Object.fromEntries(remoteGuides.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.isGuideDir)(direntPath) && guidesByKey[direntName]) {
+            return;
+        }
+        await _fsextra.remove(direntPath);
+    });
+    await Promise.all(promises);
+};
+const writeGuidesIndexDir = async (indexDirCtx, remoteGuides)=>{
+    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 pruneGuidesIndexDir(indexDirCtx, remoteGuides);
+        }
+        // Write given remote guides into the given guides directory path.
+        const writeGuideDirPromises = remoteGuides.map(async (guide)=>{
+            const guideDirPath = _nodepath.resolve(indexDirCtx.abspath, guide.key);
+            const guideDirCtx = {
+                type: "guide",
+                key: guide.key,
+                abspath: guideDirPath,
+                exists: indexDirCtx.exists ? await (0, _helpers.isGuideDir)(guideDirPath) : false
+            };
+            return writeGuideDirFromData(guideDirCtx, guide);
+        });
+        await Promise.all(writeGuideDirPromises);
+    } 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/index.isomorphic.js

@@ -7,26 +7,26 @@ Object.defineProperty(exports, "__esModule", {
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
         enumerable: true,
-        get: all[name]
+        get: Object.getOwnPropertyDescriptor(all, name).get
     });
 }
 _export(exports, {
-    buildEmailLayoutDirBundle: function() {
+    get buildEmailLayoutDirBundle () {
         return _processorisomorphic.buildEmailLayoutDirBundle;
     },
-    buildGuideDirBundle: function() {
+    get buildGuideDirBundle () {
         return _processorisomorphic1.buildGuideDirBundle;
     },
-    buildMessageTypeDirBundle: function() {
+    get buildMessageTypeDirBundle () {
         return _processorisomorphic2.buildMessageTypeDirBundle;
     },
-    buildPartialDirBundle: function() {
+    get buildPartialDirBundle () {
         return _processorisomorphic3.buildPartialDirBundle;
     },
-    buildTranslationDirBundle: function() {
+    get buildTranslationDirBundle () {
         return _processorisomorphic4.buildTranslationDirBundle;
     },
-    buildWorkflowDirBundle: function() {
+    get buildWorkflowDirBundle () {
         return _processorisomorphic5.buildWorkflowDirBundle;
     }
 });

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/lib/marshal/shared/const.isomorphic.js

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

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

@@ -8,15 +8,22 @@ Object.defineProperty(exports, "prepareResourceJson", {
         return prepareResourceJson;
     }
 });
+const _lodash = require("lodash");
 const _objectisomorphic = require("../../helpers/object.isomorphic");
+// sha and updated_at fields change too frequently, so we exclude them from resource JSON files
+const REMOVED_READONLY_FIELDS = [
+    "sha",
+    "updated_at"
+];
 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 filteredReadonlyFields = (0, _lodash.omit)(readonly, REMOVED_READONLY_FIELDS);
+    // Move remaining read only fields under the dedicated field "__readonly".
     const resourceJson = {
         ...remainder,
-        __readonly: readonly
+        __readonly: filteredReadonlyFields
     };
     // Strip out all schema annotations, so not to expose them to end users.
     return (0, _objectisomorphic.omitDeep)(resourceJson, [