@hanseltime/template-repo-sync 2.3.0 → 2.4.0-alpha.0

package/dist/cjs/plugins/json-merge.js

@@ -0,0 +1,228 @@
+"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, {
+    merge: function() {
+        return merge;
+    },
+    validate: function() {
+        return validate;
+    }
+});
+const _commentjson = /*#__PURE__*/ _interop_require_wildcard(require("comment-json"));
+const _jsonpath = /*#__PURE__*/ _interop_require_default(require("jsonpath"));
+const _lodashmerge = /*#__PURE__*/ _interop_require_default(require("lodash.merge"));
+const _inferjsonindent = require("../formatting/infer-json-indent");
+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;
+}
+function stringOptionError(value) {
+    if (value === "overwrite" || value === "merge-template" || value === "merge-current") {
+        return;
+    }
+    return `${value} must be one of type overwrite, merge-template, or merge-current`;
+}
+function validate(options) {
+    const errors = [];
+    // check for flat options
+    if (typeof options === "string") {
+        const errMsg = stringOptionError(options);
+        if (errMsg) {
+            errors.push(errMsg);
+        }
+        return errors;
+    } else {
+        if (typeof options !== "object") {
+            errors.push(`Options must be an object and not ${typeof options}`);
+            return errors;
+        }
+        if (Array.isArray(options)) {
+            errors.push(`Options must be an object and not Array`);
+            return errors;
+        }
+        if (options === null) {
+            errors.push("Options cannot be null");
+            return errors;
+        }
+    }
+    const optionsCast = options;
+    const optionKeys = Object.keys(optionsCast);
+    optionKeys.forEach((k)=>{
+        if (k === "paths") {
+            optionsCast.paths.forEach((pathObj)=>{
+                const [jsonPath, opts] = pathObj;
+                if (jsonPath.startsWith("$.")) {
+                    try {
+                        _jsonpath.default.parse(jsonPath);
+                    } catch (err) {
+                        errors.push(`Invalid jsonpath key: ${err}`);
+                        return;
+                    }
+                    const errMsg = stringOptionError(opts);
+                    if (errMsg) {
+                        errors.push(`jsonpath ${jsonPath}: ${errMsg}`);
+                    }
+                } else {
+                    errors.push(`Unrecognized jsonpath syntax: ${jsonPath}`);
+                }
+            });
+        } else {
+            if (k === "ignoreNewProperties" || k === "missingIsDelete") {
+                return;
+            }
+            errors.push(`Unrecognized key: ${k}`);
+        }
+    });
+    return errors;
+}
+async function merge(current, fromTemplateRepo, context) {
+    if (context.mergeArguments === "overwrite") {
+        return fromTemplateRepo;
+    }
+    const currentJson = _commentjson.parse(current);
+    const fromTemplateJson = _commentjson.parse(fromTemplateRepo);
+    if (context.mergeArguments === "merge-current") {
+        // Performs Lodash Merge with current as the override
+        return _commentjson.stringify((0, _lodashmerge.default)(fromTemplateJson, currentJson), null, (0, _inferjsonindent.inferJSONIndent)(current));
+    }
+    if (context.mergeArguments === "merge-template") {
+        // Performs Lodash Merge with current as the override
+        return _commentjson.stringify((0, _lodashmerge.default)(currentJson, fromTemplateJson), null, (0, _inferjsonindent.inferJSONIndent)(current));
+    }
+    const { missingIsDelete, ignoreNewProperties, paths } = context.mergeArguments;
+    const returnJson = _commentjson.parse(current);
+    paths.forEach((p)=>{
+        const [jPath, overrideType] = p;
+        const fromTemplatePaths = new Map();
+        if (overrideType === "merge-template") {
+            // We want to make sure there aren't extra paths from the template that didn't get added
+            _jsonpath.default.nodes(fromTemplateJson, jPath).forEach((n)=>{
+                fromTemplatePaths.set(_jsonpath.default.stringify(n.path), n.path);
+            });
+        }
+        _jsonpath.default.nodes(currentJson, jPath).forEach(({ path, value })=>{
+            // This solves for wildcard operators
+            const fullPath = _jsonpath.default.stringify(path);
+            // track the paths in the template we've walked
+            fromTemplatePaths.delete(fullPath);
+            _jsonpath.default.apply(returnJson, fullPath, ()=>{
+                const templateValue = _jsonpath.default.value(fromTemplateJson, fullPath);
+                if (overrideType === "merge-template") {
+                    if (templateValue === undefined) {
+                        if (missingIsDelete) {
+                            return templateValue;
+                        }
+                    } else {
+                        return applyValueMerge(value, templateValue);
+                    }
+                } else if (overrideType === "merge-current") {
+                    return applyValueMerge(templateValue, value);
+                } else if (overrideType === "overwrite") {
+                    if (templateValue !== undefined || missingIsDelete) {
+                        return templateValue;
+                    }
+                } else {
+                    throw new Error(`Unexpected JsonPath merge value ${overrideType}`);
+                }
+                return value;
+            });
+        });
+        if (!ignoreNewProperties) {
+            for (const fromTemplatePath of fromTemplatePaths.values()){
+                applyPerPath(fromTemplatePath, returnJson, fromTemplateJson);
+            }
+        }
+    });
+    if (!ignoreNewProperties) {
+        Object.keys(fromTemplateJson).forEach((key)=>{
+            if (!returnJson[key]) {
+                returnJson[key] = fromTemplateJson[key];
+            }
+        });
+    }
+    return _commentjson.stringify(returnJson, null, (0, _inferjsonindent.inferJSONIndent)(current));
+}
+/**
+ * A merge from a template to template perspective is either melding objects
+ * or completely overwriting primitive types
+ */ function applyValueMerge(base, toMerge) {
+    if (typeof base === "object" && typeof toMerge === "object") {
+        return (0, _lodashmerge.default)(base, toMerge);
+    } else {
+        return toMerge;
+    }
+}
+/**
+ * Given a nodePath on the "map" tree, this will go to the first missing element
+ * and copy that node onto the object
+ *
+ * @param nodePath
+ * @param onto
+ * @param map
+ * @param forIdx
+ */ function applyPerPath(nodePath, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+onto, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+map, forIdx = 0) {
+    if (nodePath[forIdx] === "$") {
+        applyPerPath(nodePath, onto, map, forIdx + 1);
+        return;
+    }
+    const selector = nodePath[forIdx];
+    if (onto[selector]) {
+        applyPerPath(nodePath, onto[selector], map[selector], forIdx + 1);
+        return;
+    }
+    onto[selector] = map[selector];
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/plugins/json-merge.ts"],"sourcesContent":["import * as commentJSON from \"comment-json\";\nimport type { PathComponent } from \"jsonpath\";\nimport jp from \"jsonpath\";\nimport lodashMerge from \"lodash.merge\";\nimport { inferJSONIndent } from \"../formatting/infer-json-indent\";\nimport type {\n\tJsonFileMergeOptions,\n\tJsonPathOverrides,\n\tMergeContext,\n} from \"../types\";\n\nfunction stringOptionError(value: string) {\n\tif (\n\t\tvalue === \"overwrite\" ||\n\t\tvalue === \"merge-template\" ||\n\t\tvalue === \"merge-current\"\n\t) {\n\t\treturn;\n\t}\n\treturn `${value} must be one of type overwrite, merge-template, or merge-current`;\n}\n\nexport function validate(options: unknown) {\n\tconst errors: string[] = [];\n\n\t// check for flat options\n\tif (typeof options === \"string\") {\n\t\tconst errMsg = stringOptionError(options);\n\t\tif (errMsg) {\n\t\t\terrors.push(errMsg);\n\t\t}\n\t\treturn errors;\n\t} else {\n\t\tif (typeof options !== \"object\") {\n\t\t\terrors.push(`Options must be an object and not ${typeof options}`);\n\t\t\treturn errors;\n\t\t}\n\n\t\tif (Array.isArray(options)) {\n\t\t\terrors.push(`Options must be an object and not Array`);\n\t\t\treturn errors;\n\t\t}\n\n\t\tif (options === null) {\n\t\t\terrors.push(\"Options cannot be null\");\n\t\t\treturn errors;\n\t\t}\n\t}\n\n\tconst optionsCast = options as JsonPathOverrides;\n\tconst optionKeys = Object.keys(\n\t\toptionsCast,\n\t) as unknown as (keyof JsonPathOverrides)[];\n\toptionKeys.forEach((k) => {\n\t\tif (k === \"paths\") {\n\t\t\toptionsCast.paths.forEach((pathObj) => {\n\t\t\t\tconst [jsonPath, opts] = pathObj;\n\t\t\t\tif (jsonPath.startsWith(\"$.\")) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tjp.parse(jsonPath);\n\t\t\t\t\t} catch (err) {\n\t\t\t\t\t\terrors.push(`Invalid jsonpath key: ${err}`);\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tconst errMsg = stringOptionError(opts);\n\t\t\t\t\tif (errMsg) {\n\t\t\t\t\t\terrors.push(`jsonpath ${jsonPath}: ${errMsg}`);\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\terrors.push(`Unrecognized jsonpath syntax: ${jsonPath}`);\n\t\t\t\t}\n\t\t\t});\n\t\t} else {\n\t\t\tif (k === \"ignoreNewProperties\" || k === \"missingIsDelete\") {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\terrors.push(`Unrecognized key: ${k}`);\n\t\t}\n\t});\n\treturn errors;\n}\n\nexport async function merge(\n\tcurrent: string,\n\tfromTemplateRepo: string,\n\tcontext: MergeContext<JsonFileMergeOptions>,\n): Promise<string> {\n\tif (context.mergeArguments === \"overwrite\") {\n\t\treturn fromTemplateRepo;\n\t}\n\n\tconst currentJson = commentJSON.parse(current) as commentJSON.CommentObject;\n\tconst fromTemplateJson = commentJSON.parse(\n\t\tfromTemplateRepo,\n\t) as commentJSON.CommentObject;\n\n\tif (context.mergeArguments === \"merge-current\") {\n\t\t// Performs Lodash Merge with current as the override\n\t\treturn commentJSON.stringify(\n\t\t\tlodashMerge(fromTemplateJson, currentJson),\n\t\t\tnull,\n\t\t\tinferJSONIndent(current),\n\t\t);\n\t}\n\n\tif (context.mergeArguments === \"merge-template\") {\n\t\t// Performs Lodash Merge with current as the override\n\t\treturn commentJSON.stringify(\n\t\t\tlodashMerge(currentJson, fromTemplateJson),\n\t\t\tnull,\n\t\t\tinferJSONIndent(current),\n\t\t);\n\t}\n\n\tconst { missingIsDelete, ignoreNewProperties, paths } =\n\t\tcontext.mergeArguments as JsonPathOverrides;\n\n\tconst returnJson = commentJSON.parse(current) as commentJSON.CommentObject;\n\tpaths.forEach((p) => {\n\t\tconst [jPath, overrideType] = p;\n\n\t\tconst fromTemplatePaths: Map<string, PathComponent[]> = new Map();\n\t\tif (overrideType === \"merge-template\") {\n\t\t\t// We want to make sure there aren't extra paths from the template that didn't get added\n\t\t\tjp.nodes(fromTemplateJson, jPath).forEach((n) => {\n\t\t\t\tfromTemplatePaths.set(jp.stringify(n.path), n.path);\n\t\t\t});\n\t\t}\n\t\tjp.nodes(currentJson, jPath).forEach(({ path, value }) => {\n\t\t\t// This solves for wildcard operators\n\t\t\tconst fullPath = jp.stringify(path);\n\t\t\t// track the paths in the template we've walked\n\t\t\tfromTemplatePaths.delete(fullPath);\n\t\t\tjp.apply(returnJson, fullPath, () => {\n\t\t\t\tconst templateValue = jp.value(fromTemplateJson, fullPath);\n\t\t\t\tif (overrideType === \"merge-template\") {\n\t\t\t\t\tif (templateValue === undefined) {\n\t\t\t\t\t\tif (missingIsDelete) {\n\t\t\t\t\t\t\treturn templateValue;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn applyValueMerge(value, templateValue);\n\t\t\t\t\t}\n\t\t\t\t} else if (overrideType === \"merge-current\") {\n\t\t\t\t\treturn applyValueMerge(templateValue, value);\n\t\t\t\t} else if (overrideType === \"overwrite\") {\n\t\t\t\t\tif (templateValue !== undefined || missingIsDelete) {\n\t\t\t\t\t\treturn templateValue;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tthrow new Error(`Unexpected JsonPath merge value ${overrideType}`);\n\t\t\t\t}\n\t\t\t\treturn value;\n\t\t\t});\n\t\t});\n\n\t\tif (!ignoreNewProperties) {\n\t\t\tfor (const fromTemplatePath of fromTemplatePaths.values()) {\n\t\t\t\tapplyPerPath(fromTemplatePath, returnJson, fromTemplateJson);\n\t\t\t}\n\t\t}\n\t});\n\n\tif (!ignoreNewProperties) {\n\t\tObject.keys(fromTemplateJson).forEach((key) => {\n\t\t\tif (!returnJson[key]) {\n\t\t\t\treturnJson[key] = fromTemplateJson[key];\n\t\t\t}\n\t\t});\n\t}\n\n\treturn commentJSON.stringify(returnJson, null, inferJSONIndent(current));\n}\n\n/**\n * A merge from a template to template perspective is either melding objects\n * or completely overwriting primitive types\n */\nfunction applyValueMerge(base: unknown, toMerge: unknown) {\n\tif (typeof base === \"object\" && typeof toMerge === \"object\") {\n\t\treturn lodashMerge(base, toMerge);\n\t} else {\n\t\treturn toMerge;\n\t}\n}\n\n/**\n * Given a nodePath on the \"map\" tree, this will go to the first missing element\n * and copy that node onto the object\n *\n * @param nodePath\n * @param onto\n * @param map\n * @param forIdx\n */\nfunction applyPerPath(\n\tnodePath: jp.PathComponent[],\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\tonto: any,\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\tmap: any,\n\tforIdx = 0,\n) {\n\tif (nodePath[forIdx] === \"$\") {\n\t\tapplyPerPath(nodePath, onto, map, forIdx + 1);\n\t\treturn;\n\t}\n\n\tconst selector = nodePath[forIdx];\n\tif (onto[selector]) {\n\t\tapplyPerPath(nodePath, onto[selector], map[selector], forIdx + 1);\n\t\treturn;\n\t}\n\n\tonto[selector] = map[selector];\n}\n"],"names":["merge","validate","stringOptionError","value","options","errors","errMsg","push","Array","isArray","optionsCast","optionKeys","Object","keys","forEach","k","paths","pathObj","jsonPath","opts","startsWith","jp","parse","err","current","fromTemplateRepo","context","mergeArguments","currentJson","commentJSON","fromTemplateJson","stringify","lodashMerge","inferJSONIndent","missingIsDelete","ignoreNewProperties","returnJson","p","jPath","overrideType","fromTemplatePaths","Map","nodes","n","set","path","fullPath","delete","apply","templateValue","undefined","applyValueMerge","Error","fromTemplatePath","values","applyPerPath","key","base","toMerge","nodePath","onto","map","forIdx","selector"],"mappings":"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"}