Add git caching

packages/core/src/index.ts

@@ -10,10 +10,7 @@ import { createPathResolver } from './files/paths.js';
 import { LunariaGitInstance } from './status/git.js';
 import { getDictionaryCompletion, isFileLocalizable } from './status/status.js';
 import type { LunariaStatus, StatusLocalizationEntry } from './status/types.js';
-
-// Additional data to ensure we can force rebuild the cache.
-// Bump this whenever there are breaking changes to the status output.
-const CACHE_VERSION = '1.0.0';
+import { Cache, md5 } from './utils/utils.js';
 
 // Logging levels available for the console.
 // Used to translate consola's numeric values into human-readable strings.
@@ -35,18 +32,13 @@ export class Lunaria {
 	#config: LunariaConfig;
 	#git: LunariaGitInstance;
 	#logger: ConsolaInstance;
-	// Force a fresh status build, ignoring the cache.
 	#force: boolean;
-	// Hash built out of the cache version + latest commit hash.
-	// If either changed, the status will be rebuilt.
-	#cacheHash?: string;
+	#hash: string;
 
 	constructor({ logLevel = 'info', force = false, config }: LunariaOpts = {}) {
-		const logger = createConsola({
+		this.#logger = createConsola({
 			level: CONSOLE_LEVELS[logLevel],
 		});
-
-		this.#logger = logger;
 		this.#force = force;
 
 		try {
@@ -56,34 +48,16 @@ export class Lunaria {
 			process.exit(1);
 		}
 
-		this.#git = new LunariaGitInstance(this.#config, logger);
+		// Hash used to revalidate the cache -- the tracking properties manipulate how the changes are tracked,
+		// therefore we have to account for them so that the cache is fresh.
+		this.#hash = md5(
+			`ignoredKeywords::${this.#config.tracking.ignoredKeywords.join('|')}:localizableProperty::${this.#config.tracking.localizableProperty}`,
+		);
+
+		this.#git = new LunariaGitInstance(this.#config, this.#logger, this.#force, this.#hash);
 	}
 
 	async getFullStatus() {
-		/** Uncomment when working in caching
-		const latestCommitHash = await this.#git.revparse(['HEAD']);
-		// The configuration has to be accounted to invalidate the cache
-		// since it can affect the status output.
-		const configString = JSON.stringify(this.#config);
-		const cacheHash = md5(CACHE_VERSION + latestCommitHash + configString);
-
-		const cachePath = join(this.#config.cacheDir, 'status.json');
-
-		if (existsSync(cachePath) && cacheHash === this.#cacheHash && !this.#force) {
-			try {
-				const statusJSON = readFileSync(cachePath, {
-					encoding: 'utf-8',
-				});
-				const status = JSON.parse(statusJSON);
-				this.#logger.success('Successfully loaded status from cache.');
-
-				return status as LunariaStatus;
-			} catch (e) {
-				this.#logger.warn('Failed to read status from cache, rebuilding...');
-			}
-		}
-		*/
-
 		const { files } = this.#config;
 
 		const status: LunariaStatus = [];
@@ -124,16 +98,31 @@ export class Lunaria {
 			/** We use `Promise.all` to allow the promises to run in parallel, increasing the performance considerably. */
 			await Promise.all(
 				sourceFilePaths.sort().map(async (path) => {
-					const fileStatus = await this.getFileStatus(path);
+					const fileStatus = await this.#getFileStatus(path, false);
 					if (fileStatus) status.push(fileStatus);
 				}),
 			);
 		}
 
+		// Save the existing git data into the cache for next builds.
+		if (!this.#force) {
+			new Cache(this.#config.cacheDir, 'git', this.#hash).write(this.#git.cache);
+		}
+
 		return status;
 	}
 
+	// The existence of both a public and private `getFileStatus()` is to hide
+	// the cache parameter from the public API. We do that so when we invoke
+	// it from `getFullStatus()` we only write to the cache once, considerably
+	// increasing performance (1 cache write instead of one for each file).
+	// Otherwise, when users invoke this method, they will also want to enjoy
+	// caching normally, unless they explicitly want to force a fresh status.
 	async getFileStatus(path: string) {
+		return this.#getFileStatus(path, !this.#force);
+	}
+
+	async #getFileStatus(path: string, cache: boolean) {
 		const fileConfig = this.findFileConfig(path);
 
 		if (!fileConfig) {
@@ -155,6 +144,11 @@ export class Lunaria {
 
 		const latestSourceChanges = await this.#git.getFileLatestChanges(sourcePath);
 
+		// Save the existing git data into the cache for next builds.
+		if (cache) {
+			new Cache(this.#config.cacheDir, 'git', this.#hash).write(this.#git.cache);
+		}
+
 		return {
 			...fileConfig,
 			source: {

packages/core/src/status/git.ts

@@ -4,54 +4,55 @@ import type { ConsolaInstance } from 'consola';
 import picomatch from 'picomatch';
 import { type DefaultLogFields, type ListLogLine, simpleGit } from 'simple-git';
 import type { LunariaConfig } from '../config/types.js';
-import { FileCommitsNotFound, UncommittedFileFound } from '../errors/errors.js';
+import { UncommittedFileFound } from '../errors/errors.js';
 import type { RegExpGroups } from '../utils/types.js';
+import { Cache } from '../utils/utils.js';
 
 export class LunariaGitInstance {
 	#git = simpleGit({
 		maxConcurrentProcesses: Math.max(2, Math.min(32, cpus().length)),
 	});
 	#config: LunariaConfig;
 	#logger: ConsolaInstance;
+	#force: boolean;
+	#cache: Record<string, string>;
 
-	constructor(config: LunariaConfig, logger: ConsolaInstance) {
+	constructor(config: LunariaConfig, logger: ConsolaInstance, force: boolean, hash: string) {
 		this.#logger = logger;
 		this.#config = config;
-	}
+		this.#force = force;
 
-	// TODO: Try to cache the latest changes hash for each file so that you don't have to fetch the entire history every run, only new ones.
-	async #getFileHistory(path: string) {
-		try {
-			const log = await this.#git.log({
-				file: resolve(path),
-				strictDate: true,
-			});
-
-			return log;
-		} catch (e) {
-			this.#logger.error(FileCommitsNotFound.message(path));
-			throw e;
+		if (this.#force) {
+			this.#cache = {};
+		} else {
+			const cache = new Cache(this.#config.cacheDir, 'git', hash);
+			this.#cache = cache.contents;
 		}
 	}
 
 	async getFileLatestChanges(path: string) {
-		const logHistory = await this.#getFileHistory(path);
-
-		const latestChange = logHistory.latest;
-		/**
-		 * Edge case: it might be possible all the changes for a file have
-		 * been purposefully ignored in Lunaria, therefore we need to define
-		 * the latest change as the latest tracked change.
-		 * TODO: Check if this is not an stupid assumption.
-		 */
+		// The cache will keep the latest tracked change hash, that means it will be able
+		// to completely skip looking into older commits, considerably increasing performance.
+		const log = await this.#git.log({
+			file: resolve(path),
+			strictDate: true,
+			from: this.#cache[path] ? `${this.#cache[path]}^` : undefined,
+		});
+
+		const latestChange = log.latest;
+		// Edge case: sometimes all the changes for a file (or the only one)
+		// have been purposefully ignored in Lunaria, therefore we need to
+		// define the latest change as the latest tracked change.
 		const latestTrackedChange =
-			findLatestTrackedCommit(this.#config.tracking, path, logHistory.all) ?? latestChange;
+			findLatestTrackedCommit(this.#config.tracking, path, log.all) ?? latestChange;
 
 		if (!latestChange || !latestTrackedChange) {
 			this.#logger.error(UncommittedFileFound.message(path));
 			process.exit(1);
 		}
 
+		if (!this.#force) this.#cache[path] = latestTrackedChange.hash;
+
 		return {
 			latestChange: {
 				date: latestChange.date,
@@ -65,6 +66,10 @@ export class LunariaGitInstance {
 			},
 		};
 	}
+
+	get cache() {
+		return this.#cache;
+	}
 }
 
 /**

packages/core/src/status/types.ts

@@ -4,7 +4,7 @@ export type Dictionary = {
 	[k: string]: string | Dictionary;
 };
 
-type FileGitData = {
+export type FileGitData = {
 	latestChange: {
 		message: string;
 		date: string;

packages/core/src/utils/utils.ts

@@ -1,4 +1,7 @@
 import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { jsonLoader } from '../files/loaders.js';
 
 export function isRelative(path: string) {
 	return path.startsWith('./') || path.startsWith('../');
@@ -23,3 +26,44 @@ export function stringFromFormat(format: string, placeholders: Record<string, st
 	}
 	return formatResult;
 }
+
+export class Cache {
+	#dir: string;
+	#file: string;
+	#path: string;
+	#hash: string;
+
+	constructor(dir: string, entry: string, hash: string) {
+		this.#file = `${entry}.json`;
+		this.#dir = resolve(dir);
+		this.#path = join(this.#dir, this.#file);
+		this.#hash = hash;
+
+		if (!existsSync(this.#path)) {
+			mkdirSync(this.#dir, { recursive: true });
+			this.write({ __validation: this.#hash });
+		} else {
+			this.#revalidate(this.#hash);
+		}
+	}
+
+	get contents() {
+		return jsonLoader(this.#path);
+	}
+
+	write(contents: Record<string, string>) {
+		writeFileSync(
+			this.#path,
+			JSON.stringify({
+				__validation: this.#hash,
+				...contents,
+			}),
+		);
+	}
+
+	#revalidate(hash: string) {
+		if (this.contents?.__validation !== hash) {
+			this.write({});
+		}
+	}
+}