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

package/dist/esm/plugins/json-merge.mjs

@@ -0,0 +1,164 @@
+import * as commentJSON from "comment-json";
+import jp from "jsonpath";
+import lodashMerge from "lodash.merge";
+import { inferJSONIndent } from "../formatting/infer-json-indent.mjs";
+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`;
+}
+export 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 {
+                        jp.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;
+}
+export 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(lodashMerge(fromTemplateJson, currentJson), null, inferJSONIndent(current));
+    }
+    if (context.mergeArguments === "merge-template") {
+        // Performs Lodash Merge with current as the override
+        return commentJSON.stringify(lodashMerge(currentJson, fromTemplateJson), null, 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
+            jp.nodes(fromTemplateJson, jPath).forEach((n)=>{
+                fromTemplatePaths.set(jp.stringify(n.path), n.path);
+            });
+        }
+        jp.nodes(currentJson, jPath).forEach(({ path, value })=>{
+            // This solves for wildcard operators
+            const fullPath = jp.stringify(path);
+            // track the paths in the template we've walked
+            fromTemplatePaths.delete(fullPath);
+            jp.apply(returnJson, fullPath, ()=>{
+                const templateValue = jp.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, 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 lodashMerge(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":["commentJSON","jp","lodashMerge","inferJSONIndent","stringOptionError","value","validate","options","errors","errMsg","push","Array","isArray","optionsCast","optionKeys","Object","keys","forEach","k","paths","pathObj","jsonPath","opts","startsWith","parse","err","merge","current","fromTemplateRepo","context","mergeArguments","currentJson","fromTemplateJson","stringify","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":"AAAA,YAAYA,iBAAiB,eAAe;AAE5C,OAAOC,QAAQ,WAAW;AAC1B,OAAOC,iBAAiB,eAAe;AACvC,SAASC,eAAe,QAAQ,sCAAkC;AAOlE,SAASC,kBAAkBC,KAAa;IACvC,IACCA,UAAU,eACVA,UAAU,oBACVA,UAAU,iBACT;QACD;IACD;IACA,OAAO,GAAGA,MAAM,gEAAgE,CAAC;AAClF;AAEA,OAAO,SAASC,SAASC,OAAgB;IACxC,MAAMC,SAAmB,EAAE;IAE3B,yBAAyB;IACzB,IAAI,OAAOD,YAAY,UAAU;QAChC,MAAME,SAASL,kBAAkBG;QACjC,IAAIE,QAAQ;YACXD,OAAOE,IAAI,CAACD;QACb;QACA,OAAOD;IACR,OAAO;QACN,IAAI,OAAOD,YAAY,UAAU;YAChCC,OAAOE,IAAI,CAAC,CAAC,kCAAkC,EAAE,OAAOH,SAAS;YACjE,OAAOC;QACR;QAEA,IAAIG,MAAMC,OAAO,CAACL,UAAU;YAC3BC,OAAOE,IAAI,CAAC,CAAC,uCAAuC,CAAC;YACrD,OAAOF;QACR;QAEA,IAAID,YAAY,MAAM;YACrBC,OAAOE,IAAI,CAAC;YACZ,OAAOF;QACR;IACD;IAEA,MAAMK,cAAcN;IACpB,MAAMO,aAAaC,OAAOC,IAAI,CAC7BH;IAEDC,WAAWG,OAAO,CAAC,CAACC;QACnB,IAAIA,MAAM,SAAS;YAClBL,YAAYM,KAAK,CAACF,OAAO,CAAC,CAACG;gBAC1B,MAAM,CAACC,UAAUC,KAAK,GAAGF;gBACzB,IAAIC,SAASE,UAAU,CAAC,OAAO;oBAC9B,IAAI;wBACHtB,GAAGuB,KAAK,CAACH;oBACV,EAAE,OAAOI,KAAK;wBACbjB,OAAOE,IAAI,CAAC,CAAC,sBAAsB,EAAEe,KAAK;wBAC1C;oBACD;oBACA,MAAMhB,SAASL,kBAAkBkB;oBACjC,IAAIb,QAAQ;wBACXD,OAAOE,IAAI,CAAC,CAAC,SAAS,EAAEW,SAAS,EAAE,EAAEZ,QAAQ;oBAC9C;gBACD,OAAO;oBACND,OAAOE,IAAI,CAAC,CAAC,8BAA8B,EAAEW,UAAU;gBACxD;YACD;QACD,OAAO;YACN,IAAIH,MAAM,yBAAyBA,MAAM,mBAAmB;gBAC3D;YACD;YACAV,OAAOE,IAAI,CAAC,CAAC,kBAAkB,EAAEQ,GAAG;QACrC;IACD;IACA,OAAOV;AACR;AAEA,OAAO,eAAekB,MACrBC,OAAe,EACfC,gBAAwB,EACxBC,OAA2C;IAE3C,IAAIA,QAAQC,cAAc,KAAK,aAAa;QAC3C,OAAOF;IACR;IAEA,MAAMG,cAAc/B,YAAYwB,KAAK,CAACG;IACtC,MAAMK,mBAAmBhC,YAAYwB,KAAK,CACzCI;IAGD,IAAIC,QAAQC,cAAc,KAAK,iBAAiB;QAC/C,qDAAqD;QACrD,OAAO9B,YAAYiC,SAAS,CAC3B/B,YAAY8B,kBAAkBD,cAC9B,MACA5B,gBAAgBwB;IAElB;IAEA,IAAIE,QAAQC,cAAc,KAAK,kBAAkB;QAChD,qDAAqD;QACrD,OAAO9B,YAAYiC,SAAS,CAC3B/B,YAAY6B,aAAaC,mBACzB,MACA7B,gBAAgBwB;IAElB;IAEA,MAAM,EAAEO,eAAe,EAAEC,mBAAmB,EAAEhB,KAAK,EAAE,GACpDU,QAAQC,cAAc;IAEvB,MAAMM,aAAapC,YAAYwB,KAAK,CAACG;IACrCR,MAAMF,OAAO,CAAC,CAACoB;QACd,MAAM,CAACC,OAAOC,aAAa,GAAGF;QAE9B,MAAMG,oBAAkD,IAAIC;QAC5D,IAAIF,iBAAiB,kBAAkB;YACtC,wFAAwF;YACxFtC,GAAGyC,KAAK,CAACV,kBAAkBM,OAAOrB,OAAO,CAAC,CAAC0B;gBAC1CH,kBAAkBI,GAAG,CAAC3C,GAAGgC,SAAS,CAACU,EAAEE,IAAI,GAAGF,EAAEE,IAAI;YACnD;QACD;QACA5C,GAAGyC,KAAK,CAACX,aAAaO,OAAOrB,OAAO,CAAC,CAAC,EAAE4B,IAAI,EAAExC,KAAK,EAAE;YACpD,qCAAqC;YACrC,MAAMyC,WAAW7C,GAAGgC,SAAS,CAACY;YAC9B,+CAA+C;YAC/CL,kBAAkBO,MAAM,CAACD;YACzB7C,GAAG+C,KAAK,CAACZ,YAAYU,UAAU;gBAC9B,MAAMG,gBAAgBhD,GAAGI,KAAK,CAAC2B,kBAAkBc;gBACjD,IAAIP,iBAAiB,kBAAkB;oBACtC,IAAIU,kBAAkBC,WAAW;wBAChC,IAAIhB,iBAAiB;4BACpB,OAAOe;wBACR;oBACD,OAAO;wBACN,OAAOE,gBAAgB9C,OAAO4C;oBAC/B;gBACD,OAAO,IAAIV,iBAAiB,iBAAiB;oBAC5C,OAAOY,gBAAgBF,eAAe5C;gBACvC,OAAO,IAAIkC,iBAAiB,aAAa;oBACxC,IAAIU,kBAAkBC,aAAahB,iBAAiB;wBACnD,OAAOe;oBACR;gBACD,OAAO;oBACN,MAAM,IAAIG,MAAM,CAAC,gCAAgC,EAAEb,cAAc;gBAClE;gBACA,OAAOlC;YACR;QACD;QAEA,IAAI,CAAC8B,qBAAqB;YACzB,KAAK,MAAMkB,oBAAoBb,kBAAkBc,MAAM,GAAI;gBAC1DC,aAAaF,kBAAkBjB,YAAYJ;YAC5C;QACD;IACD;IAEA,IAAI,CAACG,qBAAqB;QACzBpB,OAAOC,IAAI,CAACgB,kBAAkBf,OAAO,CAAC,CAACuC;YACtC,IAAI,CAACpB,UAAU,CAACoB,IAAI,EAAE;gBACrBpB,UAAU,CAACoB,IAAI,GAAGxB,gBAAgB,CAACwB,IAAI;YACxC;QACD;IACD;IAEA,OAAOxD,YAAYiC,SAAS,CAACG,YAAY,MAAMjC,gBAAgBwB;AAChE;AAEA;;;CAGC,GACD,SAASwB,gBAAgBM,IAAa,EAAEC,OAAgB;IACvD,IAAI,OAAOD,SAAS,YAAY,OAAOC,YAAY,UAAU;QAC5D,OAAOxD,YAAYuD,MAAMC;IAC1B,OAAO;QACN,OAAOA;IACR;AACD;AAEA;;;;;;;;CAQC,GACD,SAASH,aACRI,QAA4B,EAC5B,8DAA8D;AAC9DC,IAAS,EACT,8DAA8D;AAC9DC,GAAQ,EACRC,SAAS,CAAC;IAEV,IAAIH,QAAQ,CAACG,OAAO,KAAK,KAAK;QAC7BP,aAAaI,UAAUC,MAAMC,KAAKC,SAAS;QAC3C;IACD;IAEA,MAAMC,WAAWJ,QAAQ,CAACG,OAAO;IACjC,IAAIF,IAAI,CAACG,SAAS,EAAE;QACnBR,aAAaI,UAAUC,IAAI,CAACG,SAAS,EAAEF,GAAG,CAACE,SAAS,EAAED,SAAS;QAC/D;IACD;IAEAF,IAAI,CAACG,SAAS,GAAGF,GAAG,CAACE,SAAS;AAC/B"}