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

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

@@ -1,436 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { JsonPathOverrides } from "../types";
-import { merge, validate } from "./json-merge";
-import * as commentJson from "comment-json";
-
-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",
-  },
-};
-
-const testCommentJson = `{
-  // This is a top comment
-  "here": "here",
-  "another": 23, // this is inline
-  "inner": {
-    "el1": "el1",
-    "arr1": ["a1", "a2"],
-    "nested": {
-      // Upper comment
-      "final": "final", // Inline commment
-      "final2": "final2",
-    },
-  },
-}`;
-
-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",
-        },
-      },
-    });
-  });
-  it("performs pathjson merges on comment json", async () => {
-    const template = { ...templateFileJson };
-    (template.inner as any).nested = {
-      final: { something: 44 },
-      newThing: "this",
-    };
-
-    const testTemplateCommentJson = `{
-      "here": "heretemplate",
-      /** New comment explaining extra **/
-      "extra": "extra",
-      "inner": {
-        "arr1": ["b1", "b2"],
-        "extra2": "extra2",
-        "nested": {
-          "final": {
-            // New comment explaining final
-            "something": 44,
-          },
-          "newThing": {
-            // new thing comment
-            "this": 23,
-          },
-        }
-      },
-    }`;
-
-    expect(
-      commentJson.stringify(
-        commentJson.parse(
-          await merge(testCommentJson, testTemplateCommentJson, {
-            relFilePath: "somepath",
-            mergeArguments: {
-              paths: [
-                ["$.here", "merge-template"],
-                ["$.inner.nested.*", "merge-template"],
-                ["$.inner.nested.final", "merge-current"],
-              ],
-            },
-          }),
-        ),
-        null,
-        4,
-      ),
-    ).toEqual(
-      commentJson.stringify(
-        commentJson.parse(`{
-        // This is a top comment
-        "here": "heretemplate",
-        "another": 23, // this is inline
-        "inner": {
-          "el1": "el1",
-          "arr1": ["a1", "a2"],
-          "nested": {
-            // Upper comment
-            "final": "final", // Inline commment
-            "final2": "final2",
-            "newThing": {
-              // new thing comment
-              "this": 23,
-            },
-          },
-        },
-        "extra": "extra",
-      }`),
-        null,
-        4,
-      ),
-    );
-  });
-});
-
-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

@@ -1,215 +0,0 @@
-import {
-  MergeContext,
-  JsonFileMergeOptions,
-  JsonPathOverrides,
-} from "../types";
-import lodashMerge from "lodash.merge";
-import jp, { PathComponent } from "jsonpath";
-import { inferJSONIndent } from "../formatting/infer-json-indent";
-import * as commentJSON from "comment-json";
-
-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 = commentJSON.parse(current) as commentJSON.CommentObject;
-  const fromTemplateJson = commentJSON.parse(
-    fromTemplateRepo,
-  ) as commentJSON.CommentObject;
-
-  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 as JsonPathOverrides;
-
-  const returnJson = commentJSON.parse(current) as commentJSON.CommentObject;
-  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 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: 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];
-}

package/src/ref-drivers/git-current-ref.spec.ts

@@ -1,12 +0,0 @@
-import { execSync } from "child_process";
-import { gitCurrentRef } from "./git-current-ref";
-
-describe("getCurrentRef", () => {
-  it("gets the current sha", async () => {
-    expect(
-      await gitCurrentRef({
-        rootDir: process.cwd(),
-      }),
-    ).toEqual(execSync("git rev-parse HEAD").toString().trim());
-  });
-});

package/src/ref-drivers/git-current-ref.ts

@@ -1,9 +0,0 @@
-import { execSync } from "child_process";
-
-export async function gitCurrentRef(options: { rootDir: string }) {
-  return execSync(`git rev-parse HEAD`, {
-    cwd: options.rootDir,
-  })
-    .toString()
-    .trim();
-}

package/src/ref-drivers/index.ts

@@ -1 +0,0 @@
-export * from "./git-current-ref";

package/src/ref-drivers/types.ts

@@ -1,10 +0,0 @@
-/**
- * A function that operates within the root dir and returns the
- * current ref for its state.  This abstracts the idea of getting
- * the current commit sha, so that things like other custom templating
- * frameworks can provide their own ref
- */
-export type TemplateRefDriverFn = (options: {
-  /** The root dir where we want to get the "current" ref */
-  rootDir: string;
-}) => Promise<string>;