@hanseltime/template-repo-sync 1.0.1

package/src/merge-file.spec.ts

@@ -0,0 +1,432 @@
+import { join, resolve } from "path";
+import { mergeFile } from "./merge-file";
+import { tempDir, TEST_FIXTURES_DIR } from "./test-utils";
+import { mkdtemp, readFile, rm } from "fs/promises";
+import { copySync } from "fs-extra";
+import { JsonFileMergeOptions } from "./types";
+
+const testTemplateDir = resolve(TEST_FIXTURES_DIR, "template");
+const testDownstreamDir = resolve(TEST_FIXTURES_DIR, "downstream");
+
+describe("mergeFile", () => {
+  let tmpDir: string;
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(tempDir());
+    copySync(testDownstreamDir, tmpDir);
+  });
+  afterEach(async () => {
+    await rm(tmpDir, {
+      force: true,
+      recursive: true,
+    });
+  });
+  // Note: we use the "ignore" from the templateSync to constrain files we iterate over so it doeesn't happen here
+  // it('skips the file if it is part of template config ignroe', async () => {
+  //     expect(await mergeFile('package.json', {
+  //         cwd: tmpDir,
+  //         tempCloneDir: testTemplateDir,
+  //         localTemplateSyncConfig: {
+  //             ignore: [],
+  //             merge: {
+  //             }
+  //         },
+  //         templateSyncConfig: {
+  //             ignore: ['**/package.json'],
+  //         }
+  //     })).toBe(false)
+  // })
+  it("skips the file if it is part of local config ignore", async () => {
+    expect(
+      await mergeFile("package.json", {
+        cwd: tmpDir,
+        tempCloneDir: testTemplateDir,
+        localTemplateSyncConfig: {
+          ignore: ["**/package.json"],
+          merge: {},
+        },
+        templateSyncConfig: {
+          ignore: ["**/*.txt"],
+        },
+      }),
+    ).toEqual({
+      ignoredDueToLocal: true,
+    });
+  });
+  it("overwrites if no merge config for files", async () => {
+    expect(
+      await mergeFile("package.json", {
+        cwd: tmpDir,
+        tempCloneDir: testTemplateDir,
+        localTemplateSyncConfig: {
+          ignore: [],
+        },
+        templateSyncConfig: {
+          ignore: ["**/*.txt"],
+        },
+      }),
+    ).toEqual({
+      ignoredDueToLocal: false,
+      localChanges: [],
+    });
+
+    // Ensure we overwrote
+    expect(await readFile(join(tmpDir, "package.json"))).toEqual(
+      await readFile(join(testTemplateDir, "package.json")),
+    );
+  });
+  // Yea... these are more integration tests but I'm kinda untrusting of mocks for this
+  it("applies default [.json] merge with first rules if merge applies to file", async () => {
+    expect(
+      await mergeFile("package.json", {
+        cwd: tmpDir,
+        tempCloneDir: testTemplateDir,
+        localTemplateSyncConfig: {
+          ignore: [],
+        },
+        templateSyncConfig: {
+          ignore: ["**/*.txt"],
+          merge: {
+            ".json": {
+              // no plugins
+              rules: [
+                {
+                  glob: "**/package.json",
+                  options: "merge-current",
+                },
+                {
+                  glob: "**/package.json",
+                  options: "merge-template",
+                },
+              ],
+            },
+          },
+        },
+      }),
+    ).toEqual({
+      ignoredDueToLocal: false,
+      localChanges: [],
+    });
+
+    // Ensure we overwrote
+    expect(
+      JSON.parse((await readFile(join(tmpDir, "package.json"))).toString()),
+    ).toEqual({
+      name: "mypkg",
+      description: "my description",
+      dependencies: {
+        mypackage: "^1.2.0",
+        newpacakge: "^22.2.2",
+        package2: "3.22.1",
+        huh: "^2.30.0",
+      },
+      engines: {
+        node: ">=20",
+      },
+      scripts: {
+        build: "build",
+        test: "jest",
+        myscript: "somescript",
+      },
+      version: "new-version",
+    });
+  });
+  it("[inverse] applies default [.json] merge with first rules if merge applies to file", async () => {
+    expect(
+      await mergeFile("package.json", {
+        cwd: tmpDir,
+        tempCloneDir: testTemplateDir,
+        localTemplateSyncConfig: {
+          ignore: [],
+        },
+        templateSyncConfig: {
+          ignore: ["**/*.txt"],
+          merge: {
+            ".json": {
+              // no plugins
+              rules: [
+                {
+                  glob: "**/package.json",
+                  options: "merge-template",
+                },
+                {
+                  glob: "**/package.json",
+                  options: "merge-current",
+                },
+              ],
+            },
+          },
+        },
+      }),
+    ).toEqual({
+      ignoredDueToLocal: false,
+      localChanges: [],
+    });
+
+    // Ensure we overwrote
+    expect(
+      JSON.parse((await readFile(join(tmpDir, "package.json"))).toString()),
+    ).toEqual({
+      name: "some-stub-name",
+      description: "some-stub-description",
+      dependencies: {
+        mypackage: "^1.2.0",
+        newpacakge: "^22.2.2",
+        package2: "3.22.1",
+        huh: "~1.0.0",
+      },
+      engines: {
+        node: ">=15",
+      },
+      scripts: {
+        build: "build",
+        test: "fill this in yourself",
+        myscript: "somescript",
+      },
+      version: "new-version",
+    });
+  });
+  it("[inverse] applies default [.json] merge with sync and then local override", async () => {
+    expect(
+      await mergeFile("package.json", {
+        cwd: tmpDir,
+        tempCloneDir: testTemplateDir,
+        localTemplateSyncConfig: {
+          ignore: [],
+          merge: {
+            ".json": {
+              rules: [
+                {
+                  glob: "**/package.json",
+                  options: {
+                    paths: [
+                      // Do not touch huh
+                      ["$.dependencies.huh", "merge-current"],
+                    ],
+                  },
+                },
+              ],
+            },
+          },
+        },
+        templateSyncConfig: {
+          ignore: ["**/*.txt"],
+          merge: {
+            ".json": {
+              // no plugins
+              rules: [
+                {
+                  glob: "**/package.json",
+                  options: {
+                    missingIsDelete: true,
+                    paths: [
+                      // Merge all template dependencies
+                      ["$.dependencies", "merge-template"],
+                    ],
+                  } as JsonFileMergeOptions,
+                },
+                {
+                  glob: "**/package.json",
+                  options: "merge-current",
+                },
+              ],
+            },
+          },
+        },
+      }),
+    ).toEqual({
+      ignoredDueToLocal: false,
+      localChanges: expect.arrayContaining([
+        {
+          added: undefined,
+          count: 1,
+          removed: true,
+          value: '    "huh": "~1.0.0"\n',
+        },
+        {
+          added: true,
+          count: 1,
+          removed: undefined,
+          value: '    "huh": "^2.30.0"\n',
+        },
+      ]),
+    });
+
+    // Ensure we overwrote
+    expect(
+      JSON.parse((await readFile(join(tmpDir, "package.json"))).toString()),
+    ).toEqual({
+      name: "mypkg",
+      description: "my description",
+      dependencies: {
+        mypackage: "^1.2.0",
+        newpacakge: "^22.2.2",
+        package2: "3.22.1",
+        huh: "^2.30.0",
+      },
+      engines: {
+        node: ">=20",
+      },
+      scripts: {
+        build: "build",
+        test: "jest",
+        myscript: "somescript",
+      },
+      version: "new-version",
+    });
+  });
+  it("[inverse] applies default [.json] and custom merge for local with sync and then local override", async () => {
+    expect(
+      await mergeFile("package.json", {
+        cwd: tmpDir,
+        tempCloneDir: testTemplateDir,
+        localTemplateSyncConfig: {
+          ignore: [],
+          merge: {
+            ".json": {
+              // simulates a "node" plugin since we're pulling from the current context
+              plugin: "../test-fixtures/dummy-plugin.js",
+              rules: [
+                {
+                  glob: "**/package.json",
+                  options: {
+                    paths: [
+                      // Do not touch huh
+                      ["$.dependencies.huh", "merge-current"],
+                    ],
+                  },
+                },
+              ],
+            },
+          },
+        },
+        templateSyncConfig: {
+          ignore: ["**/*.txt"],
+          merge: {
+            ".json": {
+              // no plugins
+              rules: [
+                {
+                  glob: "**/package.json",
+                  options: {
+                    missingIsDelete: true,
+                    paths: [
+                      // Merge all template dependencies
+                      ["$.dependencies", "merge-template"],
+                    ],
+                  } as JsonFileMergeOptions,
+                },
+                {
+                  glob: "**/package.json",
+                  options: "merge-current",
+                },
+              ],
+            },
+          },
+        },
+      }),
+    ).toEqual({
+      ignoredDueToLocal: false,
+      // TODO: I don't
+      localChanges: expect.arrayContaining([
+        {
+          added: undefined,
+          count: 17,
+          removed: true,
+          value: `  "name": "mypkg",
+  "description": "my description",
+  "dependencies": {
+    "mypackage": "^1.2.0",
+    "newpacakge": "^22.2.2",
+    "package2": "3.22.1",
+    "huh": "~1.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "build",
+    "test": "jest",
+    "myscript": "somescript"
+  },
+  "version": "new-version"\n`,
+        },
+        {
+          added: true,
+          count: 1,
+          removed: undefined,
+          value: `    "tested": true\n`,
+        },
+      ]),
+    });
+
+    // Ensure we overwrote
+    expect(
+      JSON.parse((await readFile(join(tmpDir, "package.json"))).toString()),
+    ).toEqual({
+      tested: true,
+    });
+  });
+  it("[inverse] applies default [.json] and custom merge for local with sync plugin and then local override", async () => {
+    expect(
+      await mergeFile("package.json", {
+        cwd: tmpDir,
+        tempCloneDir: testTemplateDir,
+        localTemplateSyncConfig: {
+          ignore: [],
+          merge: {
+            ".json": {
+              // This is a relative path to ht
+              plugin: "plugins/custom-plugin.js",
+              rules: [
+                {
+                  glob: "**/package.json",
+                  options: {
+                    paths: [
+                      // Do not touch huh
+                      ["$.dependencies.huh", "merge-current"],
+                    ],
+                  },
+                },
+              ],
+            },
+          },
+        },
+        templateSyncConfig: {
+          ignore: ["**/*.txt"],
+          merge: {
+            ".json": {
+              // no plugins
+              rules: [
+                {
+                  glob: "**/package.json",
+                  options: {
+                    missingIsDelete: true,
+                    paths: [
+                      // Merge all template dependencies
+                      ["$.dependencies", "merge-template"],
+                    ],
+                  } as JsonFileMergeOptions,
+                },
+                {
+                  glob: "**/package.json",
+                  options: "merge-current",
+                },
+              ],
+            },
+          },
+        },
+      }),
+    ).toEqual({
+      ignoredDueToLocal: false,
+      // We are just making sure plugin look up happens here
+      localChanges: expect.arrayContaining([]),
+    });
+
+    // Ensure we overwrote
+    expect(
+      JSON.parse((await readFile(join(tmpDir, "package.json"))).toString()),
+    ).toEqual({
+      downstream: true,
+    });
+  });
+});

package/src/merge-file.ts

@@ -0,0 +1,150 @@
+import { isMatch, some } from "micromatch";
+import { Config, MergeContext, MergePlugin } from "./types";
+import { extname, join } from "path";
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { loadPlugin } from "./load-plugin";
+import { Change, diffLines } from "diff";
+import { outputFile } from "fs-extra";
+
+interface MergeFileOptions {
+  localTemplateSyncConfig: Config;
+  templateSyncConfig: Config;
+  tempCloneDir: string;
+  cwd: string;
+}
+
+interface MergeFileReturn {
+  /**
+   * If the file was ignored due to the local config
+   */
+  ignoredDueToLocal: boolean;
+  /**
+   * Only available if the file wasn't ignored, this is a list of lineDiffs
+   * from the the diff library that were applied to what would've been removed
+   */
+  localChanges?: Change[];
+}
+
+/**
+ * Applies the merge to a file according to the context information.
+ *
+ * Returns true if merged and false if skipped
+ * @param relPath
+ * @param context
+ * @returns
+ */
+export async function mergeFile(
+  relPath: string,
+  context: MergeFileOptions,
+): Promise<MergeFileReturn> {
+  const { localTemplateSyncConfig, templateSyncConfig, tempCloneDir, cwd } =
+    context;
+
+  if (some(relPath, localTemplateSyncConfig.ignore)) {
+    return {
+      ignoredDueToLocal: true,
+    };
+  }
+
+  const ext = extname(relPath);
+  const filePath = join(cwd, relPath);
+  const templatePath = join(tempCloneDir, relPath);
+
+  const mergeConfig = templateSyncConfig.merge?.[ext];
+  const localMergeConfig = localTemplateSyncConfig.merge?.[ext];
+
+  // Either write the merge or write
+  let fileContents: string;
+  const localChanges: Change[] = [];
+  if (existsSync(filePath) && (mergeConfig || localMergeConfig)) {
+    const originalCurrentFile = (await readFile(filePath)).toString();
+    if (mergeConfig) {
+      // Apply the template's most recent merges
+      const handler = await loadPlugin(mergeConfig, ext, tempCloneDir);
+
+      const mergeOptions = mergeConfig.rules.find((rule) => {
+        return isMatch(relPath, rule.glob);
+      });
+
+      if (mergeOptions) {
+        fileContents = await safeMerge(
+          handler,
+          mergeConfig.plugin ?? `default for ${ext}`,
+          originalCurrentFile,
+          (await readFile(templatePath)).toString(),
+          {
+            relFilePath: relPath,
+            mergeArguments: mergeOptions.options,
+            isLocalOptions: true,
+          },
+        );
+      } else {
+        // Apply overwrite if we didn't set up merge
+        fileContents = (await readFile(templatePath)).toString();
+      }
+    } else {
+      // Apply overwrite if we didn't set up merge
+      fileContents = (await readFile(templatePath)).toString();
+    }
+
+    // We apply the localMerge Config to the fileContent output by the template merge
+    if (localMergeConfig) {
+      const handler = await loadPlugin(localMergeConfig, ext, cwd);
+
+      const mergeOptions = localMergeConfig.rules.find((rule) => {
+        return isMatch(relPath, rule.glob);
+      });
+
+      if (mergeOptions) {
+        const localContents = await safeMerge(
+          handler,
+          localMergeConfig.plugin ?? `default for ${ext}`,
+          originalCurrentFile,
+          fileContents,
+          {
+            relFilePath: relPath,
+            mergeArguments: mergeOptions.options,
+            isLocalOptions: true,
+          },
+        );
+        localChanges.push(...diffLines(fileContents, localContents));
+        fileContents = localContents;
+      }
+    }
+  } else {
+    // Just perform simple overwrite
+    fileContents = (await readFile(templatePath)).toString();
+  }
+  await outputFile(filePath, fileContents);
+  return {
+    ignoredDueToLocal: false,
+    localChanges,
+  };
+}
+
+/**
+ * Simple helper function to ensure that we don't let bad plugins corrupt the call flow
+ * @param plugin
+ */
+async function safeMerge(
+  plugin: MergePlugin<unknown>,
+  pluginPath: string,
+  current: string,
+  fromTemplate: string,
+  context: MergeContext,
+) {
+  const ret = await plugin.merge(current, fromTemplate, context);
+  if (typeof ret !== "string") {
+    throw new Error(
+      `Plugin ${pluginPath} did not return string for merge function!  This is not allowed!`,
+    );
+  }
+
+  if (!ret) {
+    throw new Error(
+      `Plugin ${pluginPath} should not make a merge be an empty string!`,
+    );
+  }
+  return ret as string;
+}

package/src/plugins/index.ts

@@ -0,0 +1,11 @@
+import { JsonFileMergeOptions, MergePlugin } from "../types";
+import { merge as jsonMerge, validate as jsonValidate } from "./json-merge";
+
+export const defaultExtensionMap = {
+  ".json": {
+    merge: jsonMerge,
+    validate: jsonValidate,
+  },
+} as {
+  [ext: string]: MergePlugin<JsonFileMergeOptions>;
+};