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

package/dist/cjs/template-sync.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    TEMPLATE_SYNC_CONFIG: function() {
+        return TEMPLATE_SYNC_CONFIG;
+    },
+    TEMPLATE_SYNC_LOCAL_CONFIG: function() {
+        return TEMPLATE_SYNC_LOCAL_CONFIG;
+    },
+    templateSync: function() {
+        return templateSync;
+    }
+});
+const _commentjson = /*#__PURE__*/ _interop_require_wildcard(require("comment-json"));
+const _fs = require("fs");
+const _micromatch = require("micromatch");
+const _path = require("path");
+const _checkoutdrivers = require("./checkout-drivers");
+const _gitclone = require("./clone-drivers/git-clone");
+const _diffdrivers = require("./diff-drivers");
+const _formatting = require("./formatting");
+const _loadplugin = require("./load-plugin");
+const _match = require("./match");
+const _mergefile = require("./merge-file");
+const _refdrivers = require("./ref-drivers");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const TEMPLATE_SYNC_CONFIG = "templatesync";
+const TEMPLATE_SYNC_LOCAL_CONFIG = "templatesync.local";
+async function templateSync(options) {
+    const cloneDriver = options.cloneDriver ?? _gitclone.gitClone;
+    const diffDriver = options.diffDriver ?? _diffdrivers.gitDiff;
+    const currentRefDriver = options.currentRefDriver ?? _refdrivers.gitCurrentRef;
+    const checkoutDriver = options.checkoutDriver ?? _checkoutdrivers.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 = (0, _path.join)(tempCloneDir, `${TEMPLATE_SYNC_CONFIG}.json`);
+    const templateSyncConfig = (0, _fs.existsSync)(cloneConfigPath) ? _commentjson.parse((0, _fs.readFileSync)(cloneConfigPath).toString()) : {
+        ignore: []
+    };
+    const localConfigFile = `${TEMPLATE_SYNC_LOCAL_CONFIG}.json`;
+    const localConfigPath = (0, _path.join)(options.repoDir, localConfigFile);
+    const localTemplateSyncConfig = (0, _fs.existsSync)(localConfigPath) ? _commentjson.parse((0, _fs.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: (0, _match.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 (0, _loadplugin.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 (0, _loadplugin.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)=>!(0, _micromatch.some)(f, templateSyncConfig.ignore));
+    filesToSync.modified = filesToSync.modified.filter((f)=>!(0, _micromatch.some)(f, templateSyncConfig.ignore));
+    filesToSync.deleted = filesToSync.deleted.filter((f)=>!(0, _micromatch.some)(f, templateSyncConfig.ignore));
+    const localSkipFiles = new Set();
+    const localFileChanges = {};
+    const fileSyncFactory = (op)=>{
+        return async (f)=>{
+            const result = await (0, _mergefile.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 ((0, _fs.existsSync)(localConfigPath)) {
+            const configStr = (0, _fs.readFileSync)(localConfigPath).toString();
+            const config = _commentjson.parse(configStr);
+            config.afterRef = _ref;
+            (0, _fs.writeFileSync)(localConfigPath, _commentjson.stringify(config, null, (0, _formatting.inferJSONIndent)(configStr)));
+            modifiedFiles.modified.push(localConfigFile);
+        } else {
+            (0, _fs.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":["TEMPLATE_SYNC_CONFIG","TEMPLATE_SYNC_LOCAL_CONFIG","templateSync","options","cloneDriver","gitClone","diffDriver","gitDiff","currentRefDriver","gitCurrentRef","checkoutDriver","gitCheckout","cloneReturn","tmpCloneDir","repoUrl","dir","tempCloneDir","remoteName","branch","tmpDir","cloneConfigPath","join","templateSyncConfig","existsSync","commentJSON","parse","readFileSync","toString","ignore","localConfigFile","localConfigPath","repoDir","localTemplateSyncConfig","filesToSync","ref","rootDir","afterRef","localSkipFiles","localFileChanges","modifiedFiles","added","modified","deleted","total","getAllFilesInDir","localValidateErrors","validateErrors","config","merge","plugin","loadPlugin","errors","validate","length","errorStr","Object","keys","forEach","err","Error","filter","f","some","Set","fileSyncFactory","op","result","mergeFile","cwd","fileOperation","ignoredDueToLocal","add","localChanges","Promise","all","map","actualAdded","has","actualModified","actualDeleted","updateAfterRef","_ref","configStr","writeFileSync","stringify","inferJSONIndent","push","Array","from"],"mappings":"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"}