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

package/dist/esm/template-sync.mjs

@@ -0,0 +1,174 @@
+import * as commentJSON from "comment-json";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { some } from "micromatch";
+import { join } from "path";
+import { gitCheckout } from "./checkout-drivers/index.mjs";
+import { gitClone } from "./clone-drivers/git-clone.mjs";
+import { gitDiff } from "./diff-drivers/index.mjs";
+import { inferJSONIndent } from "./formatting/index.mjs";
+import { loadPlugin } from "./load-plugin.mjs";
+import { getAllFilesInDir } from "./match.mjs";
+import { mergeFile } from "./merge-file.mjs";
+import { gitCurrentRef } from "./ref-drivers/index.mjs";
+export const TEMPLATE_SYNC_CONFIG = "templatesync";
+export const TEMPLATE_SYNC_LOCAL_CONFIG = "templatesync.local";
+export async function templateSync(options) {
+    const cloneDriver = options.cloneDriver ?? gitClone;
+    const diffDriver = options.diffDriver ?? gitDiff;
+    const currentRefDriver = options.currentRefDriver ?? gitCurrentRef;
+    const checkoutDriver = options.checkoutDriver ?? gitCheckout;
+    const cloneReturn = await cloneDriver(options.tmpCloneDir, options.repoUrl);
+    const { dir: tempCloneDir, remoteName } = typeof cloneReturn === "string" ? {
+        dir: cloneReturn,
+        remoteName: "origin"
+    } : cloneReturn;
+    if (options.branch) {
+        await checkoutDriver({
+            tmpDir: tempCloneDir,
+            remoteName,
+            branch: options.branch
+        });
+    }
+    // Get the clone Config
+    const cloneConfigPath = join(tempCloneDir, `${TEMPLATE_SYNC_CONFIG}.json`);
+    const templateSyncConfig = existsSync(cloneConfigPath) ? commentJSON.parse(readFileSync(cloneConfigPath).toString()) : {
+        ignore: []
+    };
+    const localConfigFile = `${TEMPLATE_SYNC_LOCAL_CONFIG}.json`;
+    const localConfigPath = join(options.repoDir, localConfigFile);
+    const localTemplateSyncConfig = existsSync(localConfigPath) ? commentJSON.parse(readFileSync(localConfigPath).toString()) : {
+        ignore: []
+    };
+    let filesToSync;
+    const ref = await currentRefDriver({
+        rootDir: tempCloneDir
+    });
+    if (localTemplateSyncConfig.afterRef) {
+        if (ref === localTemplateSyncConfig.afterRef) {
+            // short circuit if the refs match
+            return {
+                localSkipFiles: [],
+                localFileChanges: {},
+                modifiedFiles: {
+                    added: [],
+                    modified: [],
+                    deleted: [],
+                    total: 0
+                }
+            };
+        }
+        filesToSync = await diffDriver(tempCloneDir, localTemplateSyncConfig.afterRef);
+    } else {
+        filesToSync = {
+            added: getAllFilesInDir(tempCloneDir, [
+                ...templateSyncConfig.ignore,
+                ".git/**"
+            ]),
+            deleted: [],
+            modified: []
+        };
+    }
+    // Pre-load plugins and make sure the sync file is respected
+    // Synchronous since grpc servers take a second
+    const localValidateErrors = {};
+    const validateErrors = {};
+    for (const config of localTemplateSyncConfig.merge ?? []){
+        const plugin = await loadPlugin(config, options.repoDir);
+        const errors = plugin.validate(config.options ?? {});
+        if (errors && errors.length > 0) {
+            localValidateErrors[config.plugin] = errors;
+        }
+    }
+    for (const config of templateSyncConfig.merge ?? []){
+        const plugin = await loadPlugin(config, tempCloneDir);
+        const errors = plugin.validate(config.options ?? {});
+        if (errors && errors.length > 0) {
+            validateErrors[config.plugin] = errors;
+        }
+    }
+    let errorStr = "";
+    if (Object.keys(validateErrors).length > 0) {
+        errorStr = `${errorStr}templatesync.json plugin option errors:\n`;
+        for(const plugin in validateErrors){
+            errorStr = `${errorStr}\tPlugin (${plugin}):\n`;
+            validateErrors[plugin].forEach((err)=>{
+                errorStr = `${errorStr}\t\t${err}\n`;
+            });
+        }
+    }
+    if (Object.keys(localValidateErrors).length > 0) {
+        errorStr = `${errorStr}templatesync.local.json plugin option errors:\n`;
+        for(const plugin in localValidateErrors){
+            errorStr = `${errorStr}\tPlugin (${plugin}):\n`;
+            localValidateErrors[plugin].forEach((err)=>{
+                errorStr = `${errorStr}\t\t${err}\n`;
+            });
+        }
+    }
+    if (errorStr !== "") {
+        throw Error(errorStr);
+    }
+    // Apply ignore filters
+    filesToSync.added = filesToSync.added.filter((f)=>!some(f, templateSyncConfig.ignore));
+    filesToSync.modified = filesToSync.modified.filter((f)=>!some(f, templateSyncConfig.ignore));
+    filesToSync.deleted = filesToSync.deleted.filter((f)=>!some(f, templateSyncConfig.ignore));
+    const localSkipFiles = new Set();
+    const localFileChanges = {};
+    const fileSyncFactory = (op)=>{
+        return async (f)=>{
+            const result = await mergeFile(f, {
+                localTemplateSyncConfig,
+                templateSyncConfig,
+                tempCloneDir,
+                cwd: options.repoDir,
+                fileOperation: op
+            });
+            if (result.ignoredDueToLocal) {
+                localSkipFiles.add(f);
+            } else if (result?.localChanges && result.localChanges.length > 0) {
+                localFileChanges[f] = result.localChanges;
+            }
+        };
+    };
+    // Added and modified have the same setup for now
+    await Promise.all(filesToSync.added.map(fileSyncFactory("added")));
+    await Promise.all(filesToSync.modified.map(fileSyncFactory("modified")));
+    await Promise.all(filesToSync.deleted.map(fileSyncFactory("deleted")));
+    // Report the files that changed in general
+    const actualAdded = filesToSync.added.filter((f)=>!localSkipFiles.has(f));
+    const actualModified = filesToSync.modified.filter((f)=>!localSkipFiles.has(f));
+    const actualDeleted = filesToSync.deleted.filter((f)=>!localSkipFiles.has(f));
+    const modifiedFiles = {
+        added: actualAdded,
+        modified: actualModified,
+        deleted: actualDeleted
+    };
+    // apply after ref
+    if (options.updateAfterRef) {
+        const _ref = await currentRefDriver({
+            rootDir: tempCloneDir
+        });
+        if (existsSync(localConfigPath)) {
+            const configStr = readFileSync(localConfigPath).toString();
+            const config = commentJSON.parse(configStr);
+            config.afterRef = _ref;
+            writeFileSync(localConfigPath, commentJSON.stringify(config, null, inferJSONIndent(configStr)));
+            modifiedFiles.modified.push(localConfigFile);
+        } else {
+            writeFileSync(localConfigPath, commentJSON.stringify({
+                afterRef: _ref
+            }, null, 4));
+            modifiedFiles.added.push(localConfigFile);
+        }
+    }
+    return {
+        localSkipFiles: Array.from(localSkipFiles),
+        localFileChanges,
+        modifiedFiles: {
+            ...modifiedFiles,
+            total: modifiedFiles.added.length + modifiedFiles.deleted.length + modifiedFiles.modified.length
+        }
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/template-sync.ts"],"sourcesContent":["import * as commentJSON from \"comment-json\";\nimport type { Change } from \"diff\";\nimport { existsSync, readFileSync, writeFileSync } from \"fs\";\nimport { some } from \"micromatch\";\nimport { join } from \"path\";\nimport type { TemplateCheckoutDriverFn } from \"./checkout-drivers\";\nimport { gitCheckout } from \"./checkout-drivers\";\nimport type { TemplateCloneDriverFn } from \"./clone-drivers\";\nimport { gitClone } from \"./clone-drivers/git-clone\";\nimport type { DiffResult, TemplateDiffDriverFn } from \"./diff-drivers\";\nimport { gitDiff } from \"./diff-drivers\";\nimport { inferJSONIndent } from \"./formatting\";\nimport { loadPlugin } from \"./load-plugin\";\nimport { getAllFilesInDir } from \"./match\";\nimport { mergeFile } from \"./merge-file\";\nimport { gitCurrentRef } from \"./ref-drivers\";\nimport type { TemplateRefDriverFn } from \"./ref-drivers/types\";\nimport type { Config, FileOperation, LocalConfig } from \"./types\";\n\nexport interface TemplateSyncOptions {\n\t/**\n\t * This is the url of the template repo\n\t */\n\trepoUrl: string;\n\n\t/**\n\t * Optional Branch to check out - if not specified, this checks out the\n\t * default branch of the template repo\n\t */\n\tbranch?: string;\n\n\t/**\n\t * The directory for cloning our template repo into via the cloneDriver\n\t */\n\ttmpCloneDir: string;\n\n\t/**\n\t * The repo directory path that we are going to merge toward\n\t */\n\trepoDir: string;\n\n\t/**\n\t * If set to true, template sync will apply the current ref\n\t * of the template repo to afterRef\n\t */\n\tupdateAfterRef?: boolean;\n\n\t/**\n\t * Defaults to using git clone\n\t */\n\tcloneDriver?: TemplateCloneDriverFn;\n\n\t/**\n\t * Defaults to using git diff\n\t */\n\tdiffDriver?: TemplateDiffDriverFn;\n\n\t/**\n\t * Defaults to using git current ref\n\t */\n\tcurrentRefDriver?: TemplateRefDriverFn;\n\n\t/**\n\t * Defaults to using git checkout driver\n\t */\n\tcheckoutDriver?: TemplateCheckoutDriverFn;\n}\n\nexport interface TemplateSyncReturn {\n\t/**\n\t * An array of files that were skipped outright due to a templatesync.local ignore glob\n\t */\n\tlocalSkipFiles: string[];\n\t/**\n\t * An object mapping all file paths to any merge rules that would've overridden the merge rules\n\t * of the template sync file.\n\t *\n\t * Note: right now, this shows non-changed diffs as well so you have to look for added or removed\n\t */\n\tlocalFileChanges: {\n\t\t[filePath: string]: Change[];\n\t};\n\t/**\n\t * A list of all files that are modified by this operation.  You can use total to quickly check if\n\t * there was an actual meaningful change.\n\t *\n\t * Please note, ther may be localSkipfiles and total: 0, which indicates there were changes BUT the local template\n\t * sync file rendered them meaningless.\n\t */\n\tmodifiedFiles: DiffResult & {\n\t\ttotal: number;\n\t};\n}\n\nexport const TEMPLATE_SYNC_CONFIG = \"templatesync\";\nexport const TEMPLATE_SYNC_LOCAL_CONFIG = \"templatesync.local\";\n\nexport async function templateSync(\n\toptions: TemplateSyncOptions,\n): Promise<TemplateSyncReturn> {\n\tconst cloneDriver = options.cloneDriver ?? gitClone;\n\tconst diffDriver = options.diffDriver ?? gitDiff;\n\tconst currentRefDriver = options.currentRefDriver ?? gitCurrentRef;\n\tconst checkoutDriver = options.checkoutDriver ?? gitCheckout;\n\tconst cloneReturn = await cloneDriver(options.tmpCloneDir, options.repoUrl);\n\n\tconst { dir: tempCloneDir, remoteName } =\n\t\ttypeof cloneReturn === \"string\"\n\t\t\t? {\n\t\t\t\t\tdir: cloneReturn,\n\t\t\t\t\tremoteName: \"origin\", // Default to this\n\t\t\t\t}\n\t\t\t: cloneReturn;\n\n\tif (options.branch) {\n\t\tawait checkoutDriver({\n\t\t\ttmpDir: tempCloneDir,\n\t\t\tremoteName,\n\t\t\tbranch: options.branch,\n\t\t});\n\t}\n\n\t// Get the clone Config\n\tconst cloneConfigPath = join(tempCloneDir, `${TEMPLATE_SYNC_CONFIG}.json`);\n\tconst templateSyncConfig: Config = existsSync(cloneConfigPath)\n\t\t? (commentJSON.parse(\n\t\t\t\treadFileSync(cloneConfigPath).toString(),\n\t\t\t) as unknown as Config)\n\t\t: { ignore: [] };\n\n\tconst localConfigFile = `${TEMPLATE_SYNC_LOCAL_CONFIG}.json`;\n\tconst localConfigPath = join(options.repoDir, localConfigFile);\n\tconst localTemplateSyncConfig: LocalConfig = existsSync(localConfigPath)\n\t\t? (commentJSON.parse(\n\t\t\t\treadFileSync(localConfigPath).toString(),\n\t\t\t) as unknown as LocalConfig)\n\t\t: { ignore: [] };\n\n\tlet filesToSync: DiffResult;\n\tconst ref = await currentRefDriver({\n\t\trootDir: tempCloneDir,\n\t});\n\tif (localTemplateSyncConfig.afterRef) {\n\t\tif (ref === localTemplateSyncConfig.afterRef) {\n\t\t\t// short circuit if the refs match\n\t\t\treturn {\n\t\t\t\tlocalSkipFiles: [],\n\t\t\t\tlocalFileChanges: {},\n\t\t\t\tmodifiedFiles: {\n\t\t\t\t\tadded: [],\n\t\t\t\t\tmodified: [],\n\t\t\t\t\tdeleted: [],\n\t\t\t\t\ttotal: 0,\n\t\t\t\t},\n\t\t\t};\n\t\t}\n\t\tfilesToSync = await diffDriver(\n\t\t\ttempCloneDir,\n\t\t\tlocalTemplateSyncConfig.afterRef,\n\t\t);\n\t} else {\n\t\tfilesToSync = {\n\t\t\tadded: getAllFilesInDir(tempCloneDir, [\n\t\t\t\t...templateSyncConfig.ignore,\n\t\t\t\t\".git/**\",\n\t\t\t]),\n\t\t\tdeleted: [],\n\t\t\tmodified: [],\n\t\t};\n\t}\n\n\t// Pre-load plugins and make sure the sync file is respected\n\t// Synchronous since grpc servers take a second\n\tconst localValidateErrors: {\n\t\t[k: string]: string[];\n\t} = {};\n\tconst validateErrors: {\n\t\t[k: string]: string[];\n\t} = {};\n\tfor (const config of localTemplateSyncConfig.merge ?? []) {\n\t\tconst plugin = await loadPlugin(config, options.repoDir);\n\t\tconst errors = plugin.validate(config.options ?? {});\n\t\tif (errors && errors.length > 0) {\n\t\t\tlocalValidateErrors[config.plugin] = errors;\n\t\t}\n\t}\n\tfor (const config of templateSyncConfig.merge ?? []) {\n\t\tconst plugin = await loadPlugin(config, tempCloneDir);\n\t\tconst errors = plugin.validate(config.options ?? {});\n\t\tif (errors && errors.length > 0) {\n\t\t\tvalidateErrors[config.plugin] = errors;\n\t\t}\n\t}\n\n\tlet errorStr = \"\";\n\tif (Object.keys(validateErrors).length > 0) {\n\t\terrorStr = `${errorStr}templatesync.json plugin option errors:\\n`;\n\t\tfor (const plugin in validateErrors) {\n\t\t\terrorStr = `${errorStr}\\tPlugin (${plugin}):\\n`;\n\t\t\tvalidateErrors[plugin].forEach((err) => {\n\t\t\t\terrorStr = `${errorStr}\\t\\t${err}\\n`;\n\t\t\t});\n\t\t}\n\t}\n\tif (Object.keys(localValidateErrors).length > 0) {\n\t\terrorStr = `${errorStr}templatesync.local.json plugin option errors:\\n`;\n\t\tfor (const plugin in localValidateErrors) {\n\t\t\terrorStr = `${errorStr}\\tPlugin (${plugin}):\\n`;\n\t\t\tlocalValidateErrors[plugin].forEach((err) => {\n\t\t\t\terrorStr = `${errorStr}\\t\\t${err}\\n`;\n\t\t\t});\n\t\t}\n\t}\n\n\tif (errorStr !== \"\") {\n\t\tthrow Error(errorStr);\n\t}\n\n\t// Apply ignore filters\n\tfilesToSync.added = filesToSync.added.filter(\n\t\t(f) => !some(f, templateSyncConfig.ignore),\n\t);\n\tfilesToSync.modified = filesToSync.modified.filter(\n\t\t(f) => !some(f, templateSyncConfig.ignore),\n\t);\n\tfilesToSync.deleted = filesToSync.deleted.filter(\n\t\t(f) => !some(f, templateSyncConfig.ignore),\n\t);\n\n\tconst localSkipFiles: Set<string> = new Set();\n\tconst localFileChanges: {\n\t\t[filePath: string]: Change[];\n\t} = {};\n\n\tconst fileSyncFactory = (op: FileOperation) => {\n\t\treturn async (f: string) => {\n\t\t\tconst result = await mergeFile(f, {\n\t\t\t\tlocalTemplateSyncConfig,\n\t\t\t\ttemplateSyncConfig,\n\t\t\t\ttempCloneDir,\n\t\t\t\tcwd: options.repoDir,\n\t\t\t\tfileOperation: op,\n\t\t\t});\n\t\t\tif (result.ignoredDueToLocal) {\n\t\t\t\tlocalSkipFiles.add(f);\n\t\t\t} else if (result?.localChanges && result.localChanges.length > 0) {\n\t\t\t\tlocalFileChanges[f] = result.localChanges;\n\t\t\t}\n\t\t};\n\t};\n\n\t// Added and modified have the same setup for now\n\tawait Promise.all(filesToSync.added.map(fileSyncFactory(\"added\")));\n\tawait Promise.all(filesToSync.modified.map(fileSyncFactory(\"modified\")));\n\tawait Promise.all(filesToSync.deleted.map(fileSyncFactory(\"deleted\")));\n\n\t// Report the files that changed in general\n\tconst actualAdded = filesToSync.added.filter((f) => !localSkipFiles.has(f));\n\tconst actualModified = filesToSync.modified.filter(\n\t\t(f) => !localSkipFiles.has(f),\n\t);\n\tconst actualDeleted = filesToSync.deleted.filter(\n\t\t(f) => !localSkipFiles.has(f),\n\t);\n\tconst modifiedFiles = {\n\t\tadded: actualAdded,\n\t\tmodified: actualModified,\n\t\tdeleted: actualDeleted,\n\t};\n\n\t// apply after ref\n\tif (options.updateAfterRef) {\n\t\tconst _ref = await currentRefDriver({\n\t\t\trootDir: tempCloneDir,\n\t\t});\n\n\t\tif (existsSync(localConfigPath)) {\n\t\t\tconst configStr = readFileSync(localConfigPath).toString();\n\t\t\tconst config = commentJSON.parse(configStr) as unknown as LocalConfig;\n\t\t\tconfig.afterRef = _ref;\n\t\t\twriteFileSync(\n\t\t\t\tlocalConfigPath,\n\t\t\t\tcommentJSON.stringify(config, null, inferJSONIndent(configStr)),\n\t\t\t);\n\t\t\tmodifiedFiles.modified.push(localConfigFile);\n\t\t} else {\n\t\t\twriteFileSync(\n\t\t\t\tlocalConfigPath,\n\t\t\t\tcommentJSON.stringify({ afterRef: _ref }, null, 4),\n\t\t\t);\n\t\t\tmodifiedFiles.added.push(localConfigFile);\n\t\t}\n\t}\n\n\treturn {\n\t\tlocalSkipFiles: Array.from(localSkipFiles),\n\t\tlocalFileChanges,\n\t\tmodifiedFiles: {\n\t\t\t...modifiedFiles,\n\t\t\ttotal:\n\t\t\t\tmodifiedFiles.added.length +\n\t\t\t\tmodifiedFiles.deleted.length +\n\t\t\t\tmodifiedFiles.modified.length,\n\t\t},\n\t};\n}\n"],"names":["commentJSON","existsSync","readFileSync","writeFileSync","some","join","gitCheckout","gitClone","gitDiff","inferJSONIndent","loadPlugin","getAllFilesInDir","mergeFile","gitCurrentRef","TEMPLATE_SYNC_CONFIG","TEMPLATE_SYNC_LOCAL_CONFIG","templateSync","options","cloneDriver","diffDriver","currentRefDriver","checkoutDriver","cloneReturn","tmpCloneDir","repoUrl","dir","tempCloneDir","remoteName","branch","tmpDir","cloneConfigPath","templateSyncConfig","parse","toString","ignore","localConfigFile","localConfigPath","repoDir","localTemplateSyncConfig","filesToSync","ref","rootDir","afterRef","localSkipFiles","localFileChanges","modifiedFiles","added","modified","deleted","total","localValidateErrors","validateErrors","config","merge","plugin","errors","validate","length","errorStr","Object","keys","forEach","err","Error","filter","f","Set","fileSyncFactory","op","result","cwd","fileOperation","ignoredDueToLocal","add","localChanges","Promise","all","map","actualAdded","has","actualModified","actualDeleted","updateAfterRef","_ref","configStr","stringify","push","Array","from"],"mappings":"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"}