@ryanatkn/gro 0.129.4 → 0.129.5

package/src/lib/gen.test.ts

@@ -0,0 +1,306 @@
+import {test} from 'uvu';
+import * as assert from 'uvu/assert';
+import {resolve} from 'node:path';
+
+import {to_gen_result, find_genfiles, validate_gen_module} from './gen.js';
+import {paths} from './paths.js';
+import {create_empty_config} from './config.js';
+
+const origin_id = resolve('src/foo.gen.ts');
+
+test('to_gen_result plain string', () => {
+	assert.equal(to_gen_result(origin_id, '/**/'), {
+		origin_id,
+		files: [{id: resolve('src/foo.ts'), content: '/**/', origin_id, format: true}],
+	});
+});
+
+test('to_gen_result object with a content string', () => {
+	assert.equal(to_gen_result(origin_id, {content: '/**/'}), {
+		origin_id,
+		files: [{id: resolve('src/foo.ts'), content: '/**/', origin_id, format: true}],
+	});
+});
+
+test('to_gen_result fail with an unresolved id', () => {
+	assert.throws(() => to_gen_result('src/foo.ts', {content: '/**/'}));
+});
+
+test('to_gen_result fail with a build id', () => {
+	assert.throws(() => to_gen_result(resolve('.gro/foo.js'), {content: '/**/'}));
+});
+
+test('to_gen_result fail with an empty id', () => {
+	assert.throws(() => to_gen_result('', {content: '/**/'}));
+});
+
+test('to_gen_result custom file name', () => {
+	assert.equal(
+		to_gen_result(origin_id, {
+			filename: 'fooz.ts',
+			content: '/**/',
+		}),
+		{
+			origin_id,
+			files: [{id: resolve('src/fooz.ts'), content: '/**/', origin_id, format: true}],
+		},
+	);
+});
+
+test('to_gen_result custom file name that matches the default file name', () => {
+	assert.equal(
+		to_gen_result(origin_id, {
+			filename: 'foo.ts',
+			content: '/**/',
+		}),
+		{
+			origin_id,
+			files: [{id: resolve('src/foo.ts'), content: '/**/', origin_id, format: true}],
+		},
+	);
+});
+
+test('to_gen_result fail when custom file name explicitly matches the origin', () => {
+	assert.throws(() => {
+		to_gen_result(origin_id, {
+			filename: 'foo.gen.ts',
+			content: '/**/',
+		});
+	});
+});
+
+test('to_gen_result fail when file name implicitly matches the origin', () => {
+	assert.throws(() => {
+		to_gen_result(resolve('src/foo.ts'), {content: '/**/'});
+	});
+});
+
+test('to_gen_result fail with an empty file name', () => {
+	assert.throws(() => to_gen_result(origin_id, {filename: '', content: '/**/'}));
+});
+
+test('to_gen_result additional file name parts', () => {
+	assert.equal(to_gen_result(resolve('src/foo.bar.gen.ts'), {content: '/**/'}), {
+		origin_id: resolve('src/foo.bar.gen.ts'),
+		files: [
+			{
+				id: resolve('src/foo.bar.ts'),
+				content: '/**/',
+				origin_id: resolve('src/foo.bar.gen.ts'),
+				format: true,
+			},
+		],
+	});
+});
+
+test('to_gen_result js', () => {
+	assert.equal(
+		to_gen_result(origin_id, {
+			filename: 'foo.js',
+			content: '/**/',
+		}),
+		{
+			origin_id,
+			files: [{id: resolve('src/foo.js'), content: '/**/', origin_id, format: true}],
+		},
+	);
+});
+
+test('to_gen_result implicit custom file extension', () => {
+	assert.equal(to_gen_result(resolve('src/foo.gen.json.ts'), '[/**/]'), {
+		origin_id: resolve('src/foo.gen.json.ts'),
+		files: [
+			{
+				id: resolve('src/foo.json'),
+				content: '[/**/]',
+				origin_id: resolve('src/foo.gen.json.ts'),
+				format: true,
+			},
+		],
+	});
+});
+
+test('to_gen_result implicit empty file extension', () => {
+	assert.equal(to_gen_result(resolve('src/foo.gen..ts'), '[/**/]'), {
+		origin_id: resolve('src/foo.gen..ts'),
+		files: [
+			{
+				id: resolve('src/foo'),
+				content: '[/**/]',
+				origin_id: resolve('src/foo.gen..ts'),
+				format: true,
+			},
+		],
+	});
+});
+
+test('to_gen_result implicit custom file extension with additional file name parts', () => {
+	assert.equal(to_gen_result(resolve('src/foo.bar.gen.json.ts'), {content: '[/**/]'}), {
+		origin_id: resolve('src/foo.bar.gen.json.ts'),
+		files: [
+			{
+				id: resolve('src/foo.bar.json'),
+				content: '[/**/]',
+				origin_id: resolve('src/foo.bar.gen.json.ts'),
+				format: true,
+			},
+		],
+	});
+});
+
+test('to_gen_result implicit custom file extension with many dots in between', () => {
+	assert.equal(to_gen_result(resolve('src/foo...gen.ts'), '[/**/]'), {
+		origin_id: resolve('src/foo...gen.ts'),
+		files: [
+			{
+				id: resolve('src/foo...ts'),
+				content: '[/**/]',
+				origin_id: resolve('src/foo...gen.ts'),
+				format: true,
+			},
+		],
+	});
+});
+
+test('to_gen_result fail with two parts following the .gen. pattern in the file name', () => {
+	// This just ensures consistent file names - maybe loosen the restriction?
+	// You can still implicitly name files like this,
+	// but you have to move ".bar" before ".gen".
+	assert.throws(() => to_gen_result(resolve('src/foo.gen.bar.json.ts'), '/**/'));
+});
+
+test('to_gen_result fail implicit file extension ending with a dot', () => {
+	// This just ensures consistent file names - maybe loosen the restriction?
+	// This one is more restrictive than the above,
+	// because to have a file ending with a dot
+	// you have to use an explicit file name.
+	assert.throws(() => to_gen_result(resolve('src/foo.gen...ts'), '[/**/]'));
+});
+
+test('to_gen_result fail without a .gen. pattern in the file name', () => {
+	assert.throws(() => {
+		to_gen_result(resolve('src/foo.ts'), '/**/');
+	});
+});
+
+test('to_gen_result fail without a .gen. pattern in a file name that has multiple other patterns', () => {
+	assert.throws(() => {
+		to_gen_result(resolve('src/foo.bar.baz.ts'), '/**/');
+	});
+});
+
+test('to_gen_result fail with two .gen. patterns in the file name', () => {
+	assert.throws(() => to_gen_result(resolve('src/lib/gen.gen.ts'), '/**/'));
+	assert.throws(() => to_gen_result(resolve('src/foo.gen.gen.ts'), '/**/'));
+	assert.throws(() => to_gen_result(resolve('src/foo.gen.bar.gen.ts'), '/**/'));
+	assert.throws(() => to_gen_result(resolve('src/foo.gen.bar.gen.baz.ts'), '/**/'));
+});
+
+test('to_gen_result explicit custom file extension', () => {
+	assert.equal(
+		to_gen_result(origin_id, {
+			filename: 'foo.json',
+			content: '[/**/]',
+		}),
+		{
+			origin_id,
+			files: [{id: resolve('src/foo.json'), content: '[/**/]', origin_id, format: true}],
+		},
+	);
+});
+
+test('to_gen_result explicit custom empty file extension', () => {
+	assert.equal(
+		to_gen_result(origin_id, {
+			filename: 'foo',
+			content: '[/**/]',
+		}),
+		{
+			origin_id,
+			files: [{id: resolve('src/foo'), content: '[/**/]', origin_id, format: true}],
+		},
+	);
+});
+
+test('to_gen_result explicit custom file extension ending with a dot', () => {
+	assert.equal(
+		to_gen_result(origin_id, {
+			filename: 'foo.',
+			content: '[/**/]',
+		}),
+		{
+			origin_id,
+			files: [{id: resolve('src/foo.'), content: '[/**/]', origin_id, format: true}],
+		},
+	);
+});
+
+test('to_gen_result simple array of raw files', () => {
+	assert.equal(
+		to_gen_result(origin_id, [{content: '/*1*/'}, {filename: 'foo2.ts', content: '/*2*/'}]),
+		{
+			origin_id,
+			files: [
+				{id: resolve('src/foo.ts'), content: '/*1*/', origin_id, format: true},
+				{id: resolve('src/foo2.ts'), content: '/*2*/', origin_id, format: true},
+			],
+		},
+	);
+});
+
+test('to_gen_result complex array of raw files', () => {
+	assert.equal(
+		to_gen_result(origin_id, [
+			{content: '/*1*/'},
+			{filename: 'foo2.ts', content: '/*2*/'},
+			{filename: 'foo3.ts', content: '/*3*/'},
+			{filename: 'foo4.ts', content: '/*4*/'},
+			{filename: 'foo5.json', content: '[/*5*/]'},
+		]),
+		{
+			origin_id,
+			files: [
+				{id: resolve('src/foo.ts'), content: '/*1*/', origin_id, format: true},
+				{id: resolve('src/foo2.ts'), content: '/*2*/', origin_id, format: true},
+				{id: resolve('src/foo3.ts'), content: '/*3*/', origin_id, format: true},
+				{id: resolve('src/foo4.ts'), content: '/*4*/', origin_id, format: true},
+				{id: resolve('src/foo5.json'), content: '[/*5*/]', origin_id, format: true},
+			],
+		},
+	);
+});
+
+test('to_gen_result fail with duplicate names because of omissions', () => {
+	assert.throws(() => {
+		to_gen_result(origin_id, [{content: '/*1*/'}, {content: '/*2*/'}]);
+	});
+});
+
+test('to_gen_result fail with duplicate explicit names', () => {
+	assert.throws(() => {
+		to_gen_result(origin_id, [
+			{filename: 'foo.ts', content: '/*1*/'},
+			{filename: 'foo.ts', content: '/*2*/'},
+		]);
+	});
+});
+
+test('to_gen_result fail with duplicate explicit and implicit names', () => {
+	assert.throws(() => {
+		to_gen_result(origin_id, [{content: '/*1*/'}, {filename: 'foo.ts', content: '/*2*/'}]);
+	});
+});
+
+test('validate_gen_module basic behavior', () => {
+	assert.ok(validate_gen_module({gen: Function.prototype}));
+	assert.ok(!validate_gen_module({gen: {}}));
+	assert.ok(!validate_gen_module({task: {run: {}}}));
+});
+
+test('find_genfiles_result finds gen modules in a directory', () => {
+	const find_genfiles_result = find_genfiles(['docs'], [paths.lib], create_empty_config());
+	assert.ok(find_genfiles_result.ok);
+	assert.ok(find_genfiles_result.value.resolved_input_paths.length);
+});
+
+test.run();

package/src/lib/gen.ts

@@ -0,0 +1,360 @@
+import type {Logger} from '@ryanatkn/belt/log.js';
+import {join, basename, dirname, isAbsolute} from 'node:path';
+import {mkdir, readFile, writeFile} from 'node:fs/promises';
+import {z} from 'zod';
+import type {Result} from '@ryanatkn/belt/result.js';
+import type {Timings} from '@ryanatkn/belt/timings.js';
+import {red} from '@ryanatkn/belt/styletext.js';
+import {existsSync} from 'node:fs';
+
+import {print_path} from './paths.js';
+import type {Path_Id} from './path.js';
+import type {Gro_Config} from './config.js';
+import type {Parsed_Sveltekit_Config} from './sveltekit_config.js';
+import {load_modules, type Load_Modules_Failure, type Module_Meta} from './modules.js';
+import {
+	Input_Path,
+	resolve_input_files,
+	resolve_input_paths,
+	type Resolved_Input_File,
+	type Resolved_Input_Path,
+} from './input_path.js';
+import {search_fs} from './search_fs.js';
+
+export const GEN_FILE_PATTERN_TEXT = 'gen';
+export const GEN_FILE_PATTERN = '.' + GEN_FILE_PATTERN_TEXT + '.';
+
+export const is_gen_path = (path: string): boolean => path.includes(GEN_FILE_PATTERN);
+
+export interface Gen_Result {
+	origin_id: Path_Id;
+	files: Gen_File[];
+}
+export interface Gen_File {
+	id: Path_Id;
+	content: string;
+	origin_id: Path_Id;
+	format: boolean;
+}
+
+export type Gen = (ctx: Gen_Context) => Raw_Gen_Result | Promise<Raw_Gen_Result>;
+export interface Gen_Context {
+	config: Gro_Config;
+	sveltekit_config: Parsed_Sveltekit_Config;
+	/**
+	 * Same as `import.meta.url` but in path form.
+	 */
+	origin_id: Path_Id;
+	log: Logger;
+}
+// TODO consider other return data - metadata? effects? non-file build artifacts?
+export type Raw_Gen_Result = string | Raw_Gen_File | null | Raw_Gen_Result[];
+export interface Raw_Gen_File {
+	content: string;
+	// Defaults to file name without the `.gen`, and can be a relative path.
+	// TODO maybe support a transform pattern or callback fn? like '[stem].thing.[ext]'
+	filename?: string;
+	format?: boolean; // defaults to `true`
+}
+
+export const Gen_Config = z.object({
+	imports: z.record(z.string(), z.string()).default({}),
+});
+export type Gen_Config = z.infer<typeof Gen_Config>;
+
+export interface Gen_Results {
+	results: Genfile_Module_Result[];
+	successes: Genfile_Module_Result_Success[];
+	failures: Genfile_Module_Result_Failure[];
+	input_count: number;
+	output_count: number;
+	elapsed: number;
+}
+export type Genfile_Module_Result = Genfile_Module_Result_Success | Genfile_Module_Result_Failure;
+export interface Genfile_Module_Result_Success {
+	ok: true;
+	id: Path_Id;
+	files: Gen_File[];
+	elapsed: number;
+}
+export interface Genfile_Module_Result_Failure {
+	ok: false;
+	id: Path_Id;
+	reason: string;
+	error: Error;
+	elapsed: number;
+}
+
+export const to_gen_result = (origin_id: Path_Id, raw_result: Raw_Gen_Result): Gen_Result => {
+	return {
+		origin_id,
+		files: to_gen_files(origin_id, raw_result),
+	};
+};
+
+const to_gen_files = (origin_id: Path_Id, raw_result: Raw_Gen_Result): Gen_File[] => {
+	if (raw_result === null) {
+		return [];
+	} else if (typeof raw_result === 'string') {
+		return [to_gen_file(origin_id, {content: raw_result})];
+	} else if (Array.isArray(raw_result)) {
+		const files = raw_result.flatMap((f) => to_gen_files(origin_id, f));
+		validate_gen_files(files);
+		return files;
+	}
+	return [to_gen_file(origin_id, raw_result)];
+};
+
+const to_gen_file = (origin_id: Path_Id, raw_gen_file: Raw_Gen_File): Gen_File => {
+	const {content, filename, format = true} = raw_gen_file;
+	const id = to_output_file_id(origin_id, filename);
+	return {id, content, origin_id, format};
+};
+
+const to_output_file_id = (origin_id: Path_Id, raw_file_name: string | undefined): string => {
+	if (raw_file_name === '') {
+		throw Error(`Output file name cannot be an empty string`);
+	}
+	const filename = raw_file_name ?? to_output_file_name(basename(origin_id));
+	if (isAbsolute(filename)) return filename;
+	const dir = dirname(origin_id);
+	const output_file_id = join(dir, filename);
+	if (output_file_id === origin_id) {
+		throw Error('Gen origin and output file ids cannot be the same');
+	}
+	return output_file_id;
+};
+
+export const to_output_file_name = (filename: string): string => {
+	const parts = filename.split('.');
+	const gen_pattern_index = parts.indexOf(GEN_FILE_PATTERN_TEXT);
+	if (gen_pattern_index === -1) {
+		throw Error(`Invalid gen file name - '${GEN_FILE_PATTERN_TEXT}' not found in '${filename}'`);
+	}
+	if (gen_pattern_index !== parts.lastIndexOf(GEN_FILE_PATTERN_TEXT)) {
+		throw Error(
+			`Invalid gen file name - multiple instances of '${GEN_FILE_PATTERN_TEXT}' found in '${filename}'`,
+		);
+	}
+	if (gen_pattern_index < parts.length - 3) {
+		// This check is technically unneccessary,
+		// but ensures a consistent file naming convention.
+		throw Error(
+			`Invalid gen file name - only one additional extension is allowed to follow '${GEN_FILE_PATTERN}' in '${filename}'`,
+		);
+	}
+	const final_parts: string[] = [];
+	const has_different_ext = gen_pattern_index === parts.length - 3;
+	const length = has_different_ext ? parts.length - 1 : parts.length;
+	for (let i = 0; i < length; i++) {
+		if (i === gen_pattern_index) continue; // skip the `.gen.` pattern
+		if (i === length - 1 && parts[i] === '') continue; // allow empty extension
+		final_parts.push(parts[i]);
+	}
+	return final_parts.join('.');
+};
+
+const validate_gen_files = (files: Gen_File[]) => {
+	const ids = new Set();
+	for (const file of files) {
+		if (ids.has(file.id)) {
+			throw Error(`Duplicate gen file id: ${file.id}`);
+		}
+		ids.add(file.id);
+	}
+};
+
+export type Analyzed_Gen_Result =
+	| {
+			file: Gen_File;
+			existing_content: string;
+			is_new: false;
+			has_changed: boolean;
+	  }
+	| {
+			file: Gen_File;
+			existing_content: null;
+			is_new: true;
+			has_changed: true;
+	  };
+
+export const analyze_gen_results = (gen_results: Gen_Results): Promise<Analyzed_Gen_Result[]> =>
+	Promise.all(
+		gen_results.successes
+			.map((result) => result.files.map((file) => analyze_gen_result(file)))
+			.flat(),
+	);
+
+export const analyze_gen_result = async (file: Gen_File): Promise<Analyzed_Gen_Result> => {
+	if (!existsSync(file.id)) {
+		return {
+			file,
+			existing_content: null,
+			is_new: true,
+			has_changed: true,
+		};
+	}
+	const existing_content = await readFile(file.id, 'utf8');
+	return {
+		file,
+		existing_content,
+		is_new: false,
+		has_changed: file.content !== existing_content,
+	};
+};
+
+export const write_gen_results = async (
+	gen_results: Gen_Results,
+	analyzed_gen_results: Analyzed_Gen_Result[],
+	log: Logger,
+): Promise<void> => {
+	await Promise.all(
+		gen_results.successes
+			.map((result) =>
+				result.files.map(async (file) => {
+					const analyzed = analyzed_gen_results.find((r) => r.file.id === file.id);
+					if (!analyzed) throw Error('Expected to find analyzed result: ' + file.id);
+					const log_args = [print_path(file.id), 'generated from', print_path(file.origin_id)];
+					if (analyzed.is_new) {
+						log.info('writing new', ...log_args);
+						await mkdir(dirname(file.id), {recursive: true});
+						await writeFile(file.id, file.content);
+					} else if (analyzed.has_changed) {
+						log.info('writing changed', ...log_args);
+						await writeFile(file.id, file.content);
+					} else {
+						log.info('skipping unchanged', ...log_args);
+					}
+				}),
+			)
+			.flat(),
+	);
+};
+
+export interface Found_Genfiles {
+	resolved_input_files: Resolved_Input_File[];
+	resolved_input_files_by_root_dir: Map<Path_Id, Resolved_Input_File[]>;
+	resolved_input_paths: Resolved_Input_Path[];
+}
+
+export type Find_Genfiles_Result = Result<{value: Found_Genfiles}, Find_Genfiles_Failure>;
+export type Find_Genfiles_Failure =
+	| {
+			type: 'unmapped_input_paths';
+			unmapped_input_paths: Input_Path[];
+			resolved_input_paths: Resolved_Input_Path[];
+			reasons: string[];
+	  }
+	| {
+			type: 'input_directories_with_no_files';
+			input_directories_with_no_files: Input_Path[];
+			resolved_input_files: Resolved_Input_File[];
+			resolved_input_files_by_root_dir: Map<Path_Id, Resolved_Input_File[]>;
+			resolved_input_paths: Resolved_Input_Path[];
+			reasons: string[];
+	  };
+
+/**
+ * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
+ */
+export const find_genfiles = (
+	input_paths: Input_Path[],
+	root_dirs: Path_Id[],
+	config: Gro_Config,
+	timings?: Timings,
+): Find_Genfiles_Result => {
+	const extensions: string[] = [GEN_FILE_PATTERN];
+
+	// Check which extension variation works - if it's a directory, prefer others first!
+	const timing_to_resolve_input_paths = timings?.start('resolve input paths');
+	const {resolved_input_paths, unmapped_input_paths} = resolve_input_paths(
+		input_paths,
+		root_dirs,
+		extensions,
+	);
+	timing_to_resolve_input_paths?.();
+
+	// Error if any input path could not be mapped.
+	if (unmapped_input_paths.length) {
+		return {
+			ok: false,
+			type: 'unmapped_input_paths',
+			unmapped_input_paths,
+			resolved_input_paths,
+			reasons: unmapped_input_paths.map((input_path) =>
+				red(`Input path ${print_path(input_path)} cannot be mapped to a file or directory.`),
+			),
+		};
+	}
+
+	// Find all of the files for any directories.
+	const timing_to_search_fs = timings?.start('find files');
+	const {resolved_input_files, resolved_input_files_by_root_dir, input_directories_with_no_files} =
+		resolve_input_files(resolved_input_paths, (id) =>
+			search_fs(id, {
+				filter: config.search_filters,
+				file_filter: (p) => extensions.some((e) => p.includes(e)),
+			}),
+		);
+	timing_to_search_fs?.();
+
+	// Error if any input path has no files. (means we have an empty directory)
+	if (input_directories_with_no_files.length) {
+		return {
+			ok: false,
+			type: 'input_directories_with_no_files',
+			input_directories_with_no_files,
+			resolved_input_files,
+			resolved_input_files_by_root_dir,
+			resolved_input_paths,
+			reasons: input_directories_with_no_files.map((input_path) =>
+				red(`Input directory contains no matching files: ${print_path(input_path)}`),
+			),
+		};
+	}
+
+	return {
+		ok: true,
+		value: {
+			resolved_input_files,
+			resolved_input_files_by_root_dir,
+			resolved_input_paths,
+		},
+	};
+};
+
+export interface Genfile_Module {
+	gen: Gen;
+}
+
+export type Genfile_Module_Meta = Module_Meta<Genfile_Module>;
+
+export interface Loaded_Genfiles {
+	modules: Genfile_Module_Meta[];
+	found_genfiles: Found_Genfiles;
+}
+
+export type Load_Genfiles_Result = Result<{value: Loaded_Genfiles}, Load_Genfiles_Failure>;
+export type Load_Genfiles_Failure = Load_Modules_Failure<Genfile_Module_Meta>;
+
+export const load_genfiles = async (
+	found_genfiles: Found_Genfiles,
+	timings?: Timings,
+): Promise<Load_Genfiles_Result> => {
+	const loaded_modules = await load_modules(
+		found_genfiles.resolved_input_files,
+		validate_gen_module,
+		(resolved_input_file, mod): Genfile_Module_Meta => ({id: resolved_input_file.id, mod}),
+		timings,
+	);
+	if (!loaded_modules.ok) {
+		return loaded_modules;
+	}
+	return {
+		ok: true,
+		value: {modules: loaded_modules.modules, found_genfiles},
+	};
+};
+
+export const validate_gen_module = (mod: Record<string, any>): mod is Genfile_Module =>
+	typeof mod.gen === 'function';

package/src/lib/git.test.ts

@@ -0,0 +1,34 @@
+import {test} from 'uvu';
+import * as assert from 'uvu/assert';
+
+import {
+	git_check_clean_workspace,
+	git_check_fully_staged_workspace,
+	git_current_branch_first_commit_hash,
+	git_current_branch_name,
+	git_current_commit_hash,
+} from './git.js';
+
+test('git_current_branch_name', async () => {
+	const branch_name = await git_current_branch_name();
+	assert.ok(branch_name);
+});
+
+test('git_check_clean_workspace', async () => {
+	await git_check_clean_workspace();
+});
+
+test('git_check_fully_staged_workspace', async () => {
+	await git_check_fully_staged_workspace();
+});
+
+test('git_current_commit_hash', async () => {
+	await git_current_commit_hash();
+});
+
+test('git_current_branch_first_commit_hash', async () => {
+	const first_commit_hash = await git_current_branch_first_commit_hash();
+	assert.ok(first_commit_hash);
+});
+
+test.run();