@hanseltime/template-repo-sync 1.0.1

package/src/plugins/json-merge.spec.ts

@@ -0,0 +1,350 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { JsonPathOverrides } from "../types";
+import { merge, validate } from "./json-merge";
+
+const testFileJson = {
+  here: "here",
+  another: 23,
+  inner: {
+    el1: "el1",
+    arr1: ["a1", "a2"],
+    nested: {
+      final: "final",
+      final2: "final2",
+    },
+  },
+};
+
+const templateFileJson = {
+  here: "heretemplate",
+  extra: "extra",
+  inner: {
+    arr1: ["b1", "b2"],
+    extra2: "extra2",
+  },
+};
+
+describe("merge", () => {
+  it("performs overwrite when specified", async () => {
+    const fromTemplateJson = {
+      fullOverride: true,
+    };
+    expect(
+      JSON.parse(
+        await merge(
+          JSON.stringify(testFileJson),
+          JSON.stringify(fromTemplateJson),
+          {
+            relFilePath: "somepath",
+            mergeArguments: "overwrite",
+          },
+        ),
+      ),
+    ).toEqual(fromTemplateJson);
+  });
+  it("performs lodash merge-template when specified", async () => {
+    expect(
+      JSON.parse(
+        await merge(
+          JSON.stringify(testFileJson),
+          JSON.stringify(templateFileJson),
+          {
+            relFilePath: "somepath",
+            mergeArguments: "merge-template",
+          },
+        ),
+      ),
+    ).toEqual({
+      here: "heretemplate",
+      extra: "extra",
+      another: 23,
+      inner: {
+        el1: "el1",
+        arr1: ["b1", "b2"],
+        extra2: "extra2",
+        nested: {
+          final: "final",
+          final2: "final2",
+        },
+      },
+    });
+  });
+  it("performs lodash merge-current when specified", async () => {
+    expect(
+      JSON.parse(
+        await merge(
+          JSON.stringify(testFileJson),
+          JSON.stringify(templateFileJson),
+          {
+            relFilePath: "somepath",
+            mergeArguments: "merge-current",
+          },
+        ),
+      ),
+    ).toEqual({
+      here: "here",
+      extra: "extra",
+      another: 23,
+      inner: {
+        el1: "el1",
+        arr1: ["a1", "a2"],
+        extra2: "extra2",
+        nested: {
+          final: "final",
+          final2: "final2",
+        },
+      },
+    });
+  });
+  it("performs pathjson merges with default non-path values", async () => {
+    expect(
+      JSON.parse(
+        await merge(
+          JSON.stringify(testFileJson),
+          JSON.stringify(templateFileJson),
+          {
+            relFilePath: "somepath",
+            mergeArguments: {
+              paths: [
+                ["$.here", "merge-template"],
+                ["$.inner.arr1", "merge-template"],
+                ["$.inner.el1", "overwrite"],
+              ],
+            },
+          },
+        ),
+      ),
+    ).toEqual({
+      here: "heretemplate",
+      // This is the extra here since we add missing
+      extra: "extra",
+      another: 23,
+      inner: {
+        // This will stay here
+        el1: "el1",
+        arr1: ["b1", "b2"],
+        // extra2 doesn't show up since we didn't dictate it
+        nested: {
+          final: "final",
+          final2: "final2",
+        },
+      },
+    });
+  });
+  it("performs pathjson merges with missing deletions", async () => {
+    expect(
+      JSON.parse(
+        await merge(
+          JSON.stringify(testFileJson),
+          JSON.stringify(templateFileJson),
+          {
+            relFilePath: "somepath",
+            mergeArguments: {
+              missingIsDelete: true,
+              paths: [
+                ["$.here", "merge-template"],
+                ["$.inner.nested", "overwrite"],
+              ],
+            },
+          },
+        ),
+      ),
+    ).toEqual({
+      here: "heretemplate",
+      extra: "extra",
+      another: 23,
+      inner: {
+        el1: "el1",
+        arr1: ["a1", "a2"],
+        // nested is gone because it was undefined
+      },
+    });
+  });
+  it("performs pathjson merges with ignore new", async () => {
+    expect(
+      JSON.parse(
+        await merge(
+          JSON.stringify(testFileJson),
+          JSON.stringify(templateFileJson),
+          {
+            relFilePath: "somepath",
+            mergeArguments: {
+              ignoreNewProperties: true,
+              paths: [
+                ["$.here", "merge-template"],
+                ["$.inner.arr1", "merge-template"],
+              ],
+            },
+          },
+        ),
+      ),
+    ).toEqual({
+      here: "heretemplate",
+      //  extra: 'extra', - not added
+      another: 23,
+      inner: {
+        el1: "el1",
+        arr1: ["b1", "b2"],
+        nested: {
+          final: "final",
+          final2: "final2",
+        },
+      },
+    });
+  });
+  it("performs pathjson merges with no missing delete", async () => {
+    expect(
+      JSON.parse(
+        await merge(
+          JSON.stringify(testFileJson),
+          JSON.stringify(templateFileJson),
+          {
+            relFilePath: "somepath",
+            mergeArguments: {
+              paths: [
+                ["$.here", "merge-template"],
+                ["$.inner.nested", "merge-template"],
+              ],
+            },
+          },
+        ),
+      ),
+    ).toEqual({
+      here: "heretemplate",
+      extra: "extra",
+      another: 23,
+      inner: {
+        el1: "el1",
+        arr1: ["a1", "a2"],
+        nested: {
+          final: "final",
+          final2: "final2",
+        },
+      },
+    });
+  });
+  it("performs pathjson merges on multipath selection", async () => {
+    const template = { ...templateFileJson };
+    (template.inner as any).nested = {
+      final: { something: 44 },
+      newThing: "this",
+    };
+    expect(
+      JSON.parse(
+        await merge(JSON.stringify(testFileJson), JSON.stringify(template), {
+          relFilePath: "somepath",
+          mergeArguments: {
+            paths: [
+              ["$.here", "merge-template"],
+              ["$.inner.nested.*", "merge-template"],
+            ],
+          },
+        }),
+      ),
+    ).toEqual({
+      here: "heretemplate",
+      extra: "extra",
+      another: 23,
+      inner: {
+        el1: "el1",
+        arr1: ["a1", "a2"],
+        nested: {
+          final: { something: 44 },
+          final2: "final2",
+          newThing: "this",
+        },
+      },
+    });
+  });
+  it("performs pathjson merges on stacked selections", async () => {
+    const template = { ...templateFileJson };
+    (template.inner as any).nested = {
+      final: { something: 44 },
+      newThing: "this",
+    };
+    expect(
+      JSON.parse(
+        await merge(JSON.stringify(testFileJson), JSON.stringify(template), {
+          relFilePath: "somepath",
+          mergeArguments: {
+            paths: [
+              ["$.here", "merge-template"],
+              ["$.inner.nested.*", "merge-template"],
+              ["$.inner.nested.final", "merge-current"],
+            ],
+          },
+        }),
+      ),
+    ).toEqual({
+      here: "heretemplate",
+      extra: "extra",
+      another: 23,
+      inner: {
+        el1: "el1",
+        arr1: ["a1", "a2"],
+        nested: {
+          final: "final",
+          final2: "final2",
+          // We only added the newThing
+          newThing: "this",
+        },
+      },
+    });
+  });
+});
+
+describe("validate", () => {
+  it("passes correct flat mapped values", () => {
+    expect(validate("merge-template")).toEqual([]);
+  });
+  it("passes correct options object", () => {
+    expect(
+      validate({
+        ignoreNewProperties: true,
+        missingIsDelete: false,
+        paths: [
+          ["$.something", "merge-current"],
+          ["$.something[*].values", "merge-current"],
+        ],
+      } as JsonPathOverrides),
+    ).toEqual([]);
+  });
+  it("returns an error if a flat map value is not correct", () => {
+    expect(validate("bad-merge-options")).toEqual([
+      "bad-merge-options must be one of type overwrite, merge-template, or merge-current",
+    ]);
+  });
+  it("returns an unknown key exits in options object", () => {
+    expect(
+      validate({
+        unknownKey: "something",
+        paths: [
+          ["$.here", "merge-template"],
+          ["$.inner.nested.*", "merge-template"],
+          ["$.inner.nested.final", "merge-current"],
+        ],
+      }),
+    ).toEqual(["Unrecognized key: unknownKey"]);
+  });
+  it("returns a type error if the options object is an array", () => {
+    expect(validate([])).toEqual(["Options must be an object and not Array"]);
+  });
+  it("returns a type error if the options object is  null", () => {
+    expect(validate(null)).toEqual(["Options cannot be null"]);
+  });
+  it("returns a type error for each path that is invalid", () => {
+    expect(
+      validate({
+        paths: [
+          ["$.badc/value", "merge-template"],
+          ["no$", "merge-template"],
+          ["$.something", "not a value"],
+        ],
+      }),
+    ).toEqual([
+      "Invalid jsonpath key: Error: Lexical error on line 1. Unrecognized text.\n$.badc/value\n------^",
+      "Unrecognized jsonpath syntax: no$",
+      "jsonpath $.something: not a value must be one of type overwrite, merge-template, or merge-current",
+    ]);
+  });
+});

package/src/plugins/json-merge.ts

@@ -0,0 +1,205 @@
+import {
+  MergeContext,
+  JsonFileMergeOptions,
+  JsonPathOverrides,
+} from "../types";
+import lodashMerge from "lodash.merge";
+import locashCloneDeep from "lodash.clonedeep";
+import jp, { PathComponent } from "jsonpath";
+import { inferJSONIndent } from "../formatting/infer-json-indent";
+
+function stringOptionError(value: string) {
+  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: unknown) {
+  const errors: string[] = [];
+
+  // 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 as JsonPathOverrides;
+  const optionKeys = Object.keys(
+    optionsCast,
+  ) as unknown as (keyof JsonPathOverrides)[];
+  optionKeys.forEach((k) => {
+    if (k === "paths") {
+      optionsCast.paths.forEach((pathObj) => {
+        const [jsonPath, options] = pathObj;
+        if (jsonPath.startsWith("$.")) {
+          try {
+            jp.parse(jsonPath);
+          } catch (err) {
+            errors.push(`Invalid jsonpath key: ${err}`);
+            return;
+          }
+          const errMsg = stringOptionError(options);
+          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: string,
+  fromTemplateRepo: string,
+  context: MergeContext<JsonFileMergeOptions>,
+): Promise<string> {
+  if (context.mergeArguments === "overwrite") {
+    return fromTemplateRepo;
+  }
+
+  const currentJson = JSON.parse(current);
+  const fromTemplateJson = JSON.parse(fromTemplateRepo);
+
+  if (context.mergeArguments === "merge-current") {
+    // Performs Lodash Merge with current as the override
+    return JSON.stringify(lodashMerge(fromTemplateJson, currentJson), null, 4);
+  }
+
+  if (context.mergeArguments === "merge-template") {
+    // Performs Lodash Merge with current as the override
+    return JSON.stringify(lodashMerge(currentJson, fromTemplateJson), null, 4);
+  }
+
+  const { missingIsDelete, ignoreNewProperties, paths } =
+    context.mergeArguments as JsonPathOverrides;
+
+  const returnJson = locashCloneDeep(currentJson);
+  paths.forEach((p) => {
+    const [jPath, overrideType] = p;
+
+    const fromTemplatePaths: Map<string, PathComponent[]> = 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 JSON.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: unknown, toMerge: unknown) {
+  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: jp.PathComponent[],
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  onto: any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  map: any,
+  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];
+}