@ryanatkn/gro 0.129.4 → 0.129.6

package/src/lib/resolve_specifier.test.ts

@@ -0,0 +1,76 @@
+import {test} from 'uvu';
+import * as assert from 'uvu/assert';
+import {join} from 'node:path';
+
+import {resolve_specifier} from './resolve_specifier.js';
+import {paths} from './paths.js';
+
+const dir = paths.source + 'fixtures/';
+
+test('resolves a specifier to a file that exists with an unknown file extension', () => {
+	assert.equal(resolve_specifier(join(dir, 'test_file.other.ext'), dir), {
+		specifier: './test_file.other.ext',
+		path_id: join(dir, 'test_file.other.ext'),
+		namespace: undefined,
+	});
+});
+
+test('resolves a ts specifier', () => {
+	assert.equal(resolve_specifier(join(dir, 'test_ts.ts'), dir), {
+		specifier: './test_ts.js',
+		path_id: join(dir, 'test_ts.ts'),
+		namespace: 'sveltekit_local_imports_ts',
+	});
+});
+
+test('resolves relative ts specifiers', () => {
+	assert.equal(resolve_specifier('./test_ts.ts', dir), {
+		specifier: './test_ts.js',
+		path_id: join(dir, 'test_ts.ts'),
+		namespace: 'sveltekit_local_imports_ts',
+	});
+	assert.equal(resolve_specifier('./a/b/test_ts.ts', dir), {
+		specifier: './a/b/test_ts.js',
+		path_id: join(dir, 'a/b/test_ts.ts'),
+		namespace: 'sveltekit_local_imports_ts',
+	});
+	assert.equal(resolve_specifier('../../test_ts.ts', dir), {
+		specifier: '../../test_ts.js',
+		path_id: join(dir, '../../test_ts.ts'),
+		namespace: 'sveltekit_local_imports_ts',
+	});
+});
+
+test('resolves an extensionless specifier', () => {
+	assert.equal(resolve_specifier(join(dir, 'test_ts'), dir), {
+		specifier: './test_ts.js',
+		path_id: join(dir, 'test_ts.ts'),
+		namespace: 'sveltekit_local_imports_ts',
+	});
+});
+
+test('resolves a js specifier', () => {
+	assert.equal(resolve_specifier(join(dir, 'test_js.js'), dir), {
+		specifier: './test_js.js',
+		path_id: join(dir, 'test_js.js'),
+		namespace: 'sveltekit_local_imports_js',
+	});
+});
+
+test('resolves a js specifier as ts for a file that does not exist', () => {
+	assert.equal(resolve_specifier(join(dir, 'test_missing.js'), dir), {
+		specifier: './test_missing.js',
+		path_id: join(dir, 'test_missing.ts'),
+		namespace: 'sveltekit_local_imports_ts',
+	});
+});
+
+test('resolves an extensionless specifier for a file that does not exist', () => {
+	assert.equal(resolve_specifier(join(dir, 'test_missing'), dir), {
+		specifier: './test_missing.js',
+		path_id: join(dir, 'test_missing.ts'),
+		namespace: 'sveltekit_local_imports_ts',
+	});
+});
+
+test.run();

package/src/lib/resolve_specifier.ts

@@ -0,0 +1,61 @@
+import {extname, isAbsolute, join, relative} from 'node:path';
+import {existsSync} from 'node:fs';
+
+import {replace_extension} from './paths.js';
+import type {Path_Id} from './path.js';
+
+export interface Resolved_Specifier {
+	specifier: string;
+	path_id: Path_Id;
+	namespace: undefined | 'sveltekit_local_imports_ts' | 'sveltekit_local_imports_js';
+}
+
+/**
+ * Maps a `path` import specifier relative to the `importer`,
+ * and infer the correct extension following Vite conventions.
+ * If no `.js` file is found for the `path` on the filesystem, it assumes `.ts`.
+ * @param path
+ * @param dir - if defined, enables relative importers like from esbuild plugins
+ * @param passthrough_extensions - used to support specifiers that have no file extention, which Vite supports, so we do our best effort
+ * @returns
+ */
+export const resolve_specifier = (path: string, dir: string): Resolved_Specifier => {
+	const absolute_path = isAbsolute(path) ? path : join(dir, path);
+
+	let mapped_path;
+	let path_id;
+	let namespace: Resolved_Specifier['namespace'];
+
+	const ext = extname(absolute_path);
+	const is_js = ext === '.js';
+	const is_ts = ext === '.ts';
+
+	if (!is_js && !is_ts && existsSync(absolute_path)) {
+		// unrecognized extension and the file exists
+		mapped_path = absolute_path;
+		path_id = absolute_path;
+	} else if (is_ts) {
+		// explicitly ts
+		mapped_path = replace_extension(absolute_path, '.js');
+		path_id = absolute_path;
+		namespace = 'sveltekit_local_imports_ts';
+	} else {
+		// extensionless, or js that points to ts, or just js
+		const js_id = is_js ? absolute_path : absolute_path + '.js';
+		const ts_id = is_js ? replace_extension(absolute_path, '.ts') : absolute_path + '.ts';
+		if (!existsSync(ts_id) && existsSync(js_id)) {
+			mapped_path = js_id;
+			path_id = js_id;
+			namespace = 'sveltekit_local_imports_js';
+		} else {
+			mapped_path = js_id;
+			path_id = ts_id;
+			namespace = 'sveltekit_local_imports_ts';
+		}
+	}
+
+	let specifier = relative(dir, mapped_path);
+	if (specifier[0] !== '.') specifier = './' + specifier;
+
+	return {specifier, path_id, namespace};
+};

package/src/lib/run.task.ts

@@ -0,0 +1,41 @@
+import {z} from 'zod';
+import {green, cyan} from '@ryanatkn/belt/styletext.js';
+import {existsSync} from 'node:fs';
+
+import {Task_Error, type Task} from './task.js';
+import {resolve_gro_module_path, spawn_with_loader} from './gro_helpers.js';
+
+export const Args = z
+	.object({
+		_: z
+			.array(z.string(), {description: 'the file path to run and other node CLI args'})
+			.default([]),
+	})
+	.strict();
+export type Args = z.infer<typeof Args>;
+
+export const task: Task<Args> = {
+	summary: 'execute a file with the loader, like `node` but works for TypeScript',
+	Args,
+	run: async ({args, log}) => {
+		const {
+			_: [path, ...argv],
+		} = args;
+
+		if (!path) {
+			log.info(green('\n\nUsage: ') + cyan('gro run path/to/file.ts [...node_args]\n'));
+			return;
+		}
+
+		if (!existsSync(path)) {
+			throw new Task_Error('Cannot find file to run at path: ' + path);
+		}
+
+		const loader_path = resolve_gro_module_path('loader.js');
+
+		const spawned = await spawn_with_loader(loader_path, path, argv);
+		if (!spawned.ok) {
+			throw new Task_Error(`\`gro run ${path}\` failed with exit code ${spawned.code}`);
+		}
+	},
+};

package/src/lib/run_gen.test.ts

@@ -0,0 +1,196 @@
+import {suite} from 'uvu';
+import * as assert from 'uvu/assert';
+import {resolve, join} from 'node:path';
+import {Logger} from '@ryanatkn/belt/log.js';
+import {Timings} from '@ryanatkn/belt/timings.js';
+
+import type {Genfile_Module_Meta} from './gen.js';
+import {run_gen} from './run_gen.js';
+import {load_config} from './config.js';
+
+const log = new Logger('test__gen'); // TODO test logger?
+
+/* test__gen */
+const test__gen = suite('gen');
+
+test__gen('basic behavior', async () => {
+	const path_id_a = resolve('src/foo.gen.ts');
+	const path_id_bc = resolve('src/bar/bc');
+	let file_a: undefined | {filename: string; content: string};
+	let file_b: undefined | {filename: string; content: string};
+	let file_c1: undefined | {filename: string; content: string};
+	let file_c2: undefined | {filename: string; content: string};
+	const mod_a: Genfile_Module_Meta = {
+		id: path_id_a,
+		mod: {
+			gen: (ctx) => {
+				assert.is(ctx.origin_id, path_id_a);
+				if (file_a) throw Error('Already generated file_a');
+				file_a = {
+					filename: 'foo.ts',
+					content: 'file_a',
+				};
+				return file_a.content; // here we return the shorthand version
+			},
+		},
+	};
+	const mod_b: Genfile_Module_Meta = {
+		id: join(path_id_bc, 'mod_b.gen.ts'),
+		mod: {
+			gen: (ctx) => {
+				assert.is(ctx.origin_id, mod_b.id);
+				if (file_b) throw Error('Already generated file_b');
+				file_b = {
+					filename: 'output_b.ts',
+					content: 'file_b',
+				};
+				return file_b;
+			},
+		},
+	};
+	const mod_c: Genfile_Module_Meta = {
+		id: join(path_id_bc, 'mod_c.gen.ts'),
+		mod: {
+			gen: (ctx) => {
+				assert.is(ctx.origin_id, mod_c.id);
+				if (file_c1) throw Error('Already generated file_c1');
+				if (file_c2) throw Error('Already generated file_c2');
+				file_c1 = {
+					filename: 'output_c1.ts',
+					content: 'file_c1',
+				};
+				file_c2 = {
+					filename: 'output_c2.ts',
+					content: 'file_c2',
+				};
+				return [file_c1, file_c2];
+			},
+		},
+	};
+	const gen_modules_by_input_path = [mod_a, mod_b, mod_c];
+	const gen_results = await run_gen(
+		gen_modules_by_input_path,
+		await load_config(),
+		log,
+		new Timings(),
+		(content, opts) =>
+			Promise.resolve(opts.filepath!.endsWith('output_b.ts') ? `${content}/*FORMATTED*/` : content),
+	);
+	assert.is(gen_results.input_count, 3);
+	assert.is(gen_results.output_count, 4);
+	assert.is(gen_results.successes.length, 3);
+	assert.is(gen_results.failures.length, 0);
+	assert.is(gen_results.results.length, 3);
+	assert.is(gen_results.results[0], gen_results.successes[0]);
+	assert.is(gen_results.results[1], gen_results.successes[1]);
+	assert.is(gen_results.results[2], gen_results.successes[2]);
+
+	const result_a = gen_results.results[0];
+	assert.ok(result_a.ok);
+	assert.ok(file_a);
+	assert.equal(result_a.files, [
+		{
+			content: file_a.content,
+			id: join(mod_a.id, '../', file_a.filename),
+			origin_id: mod_a.id,
+			format: true,
+		},
+	]);
+
+	const result_b = gen_results.results[1];
+	assert.ok(result_b.ok);
+	assert.ok(file_b);
+	assert.equal(result_b.files, [
+		{
+			content: `${file_b.content}/*FORMATTED*/`,
+			id: join(mod_b.id, '../', file_b.filename),
+			origin_id: mod_b.id,
+			format: true,
+		},
+	]);
+	const result_c = gen_results.results[2];
+	assert.ok(result_c.ok);
+	assert.ok(file_c1);
+	assert.ok(file_c2);
+	assert.equal(result_c.files, [
+		{
+			content: file_c1.content,
+			id: join(mod_c.id, '../', file_c1.filename),
+			origin_id: mod_c.id,
+			format: true,
+		},
+		{
+			content: file_c2.content,
+			id: join(mod_c.id, '../', file_c2.filename),
+			origin_id: mod_c.id,
+			format: true,
+		},
+	]);
+});
+
+test__gen('failing gen function', async () => {
+	const path_id_a = resolve('src/foo.gen.ts');
+	const path_idB = resolve('src/bar/baz');
+	let file_b: undefined | {filename: string; content: string}; // no file_a because it's never generated
+	let genError; // this error should be passed through to the result
+	// This is the failing gen module.
+	// It's ordered first to test that its failure doesn't cascade.
+	const mod_a: Genfile_Module_Meta = {
+		id: path_id_a,
+		mod: {
+			gen: () => {
+				genError = Error('This fails for testing');
+				throw genError;
+			},
+		},
+	};
+	const mod_b: Genfile_Module_Meta = {
+		id: join(path_idB, 'mod_b.gen.ts'),
+		mod: {
+			gen: (ctx) => {
+				assert.is(ctx.origin_id, mod_b.id);
+				if (file_b) throw Error('Already generated file_b');
+				file_b = {
+					filename: 'output_b.ts',
+					content: 'file_b',
+				};
+				return file_b;
+			},
+		},
+	};
+	const gen_modules_by_input_path: Genfile_Module_Meta[] = [mod_a, mod_b];
+	const gen_results = await run_gen(
+		gen_modules_by_input_path,
+		await load_config(),
+		log,
+		new Timings(),
+	);
+	assert.is(gen_results.input_count, 2);
+	assert.is(gen_results.output_count, 1);
+	assert.is(gen_results.successes.length, 1);
+	assert.is(gen_results.failures.length, 1);
+	assert.is(gen_results.results.length, 2);
+	assert.is(gen_results.results[0], gen_results.failures[0]);
+	assert.is(gen_results.results[1], gen_results.successes[0]);
+
+	const result_a = gen_results.results[0];
+	assert.ok(result_a);
+	assert.ok(!result_a.ok);
+	assert.ok(result_a.reason);
+	assert.ok(result_a.error);
+
+	const result_b = gen_results.results[1];
+	assert.ok(result_b.ok);
+	assert.ok(file_b);
+	assert.equal(result_b.files, [
+		{
+			content: file_b.content,
+			id: join(mod_b.id, '../', file_b.filename),
+			origin_id: mod_b.id,
+			format: true,
+		},
+	]);
+});
+
+test__gen.run();
+/* test__gen */

package/src/lib/run_gen.ts

@@ -0,0 +1,95 @@
+import {red} from '@ryanatkn/belt/styletext.js';
+import {print_error} from '@ryanatkn/belt/print.js';
+import type {Timings} from '@ryanatkn/belt/timings.js';
+import type {Logger} from '@ryanatkn/belt/log.js';
+
+import {
+	type Gen_Results,
+	type Genfile_Module_Result,
+	type Gen_Context,
+	type Genfile_Module_Meta,
+	to_gen_result,
+	type Raw_Gen_Result,
+} from './gen.js';
+import {print_path} from './paths.js';
+import type {format_file as base_format_file} from './format_file.js';
+import type {Gro_Config} from './config.js';
+import {sveltekit_config_global} from './sveltekit_config_global.js';
+
+export const GEN_NO_PROD_MESSAGE = 'gen runs only during development';
+
+export const run_gen = async (
+	gen_modules: Genfile_Module_Meta[],
+	config: Gro_Config,
+	log: Logger,
+	timings: Timings,
+	format_file?: typeof base_format_file,
+): Promise<Gen_Results> => {
+	let input_count = 0;
+	let output_count = 0;
+	const timing_for_run_gen = timings.start('run_gen');
+	const results = await Promise.all(
+		gen_modules.map(async (module_meta): Promise<Genfile_Module_Result> => {
+			input_count++;
+			const {id} = module_meta;
+			const timing_for_module = timings.start(id);
+
+			// Perform code generation by calling `gen` on the module.
+			const gen_ctx: Gen_Context = {
+				config,
+				sveltekit_config: sveltekit_config_global,
+				origin_id: id,
+				log,
+			};
+			let raw_gen_result: Raw_Gen_Result;
+			try {
+				raw_gen_result = await module_meta.mod.gen(gen_ctx);
+			} catch (err) {
+				return {
+					ok: false,
+					id,
+					error: err,
+					reason: red(`Error generating ${print_path(id)}`),
+					elapsed: timing_for_module(),
+				};
+			}
+
+			// Convert the module's return value to a normalized form.
+			const gen_result = to_gen_result(id, raw_gen_result);
+
+			// Format the files if needed.
+			const files = format_file
+				? await Promise.all(
+						gen_result.files.map(async (file) => {
+							if (!file.format) return file;
+							try {
+								return {...file, content: await format_file(file.content, {filepath: file.id})};
+							} catch (err) {
+								log.error(
+									red(`Error formatting ${print_path(file.id)} via ${print_path(id)}`),
+									print_error(err),
+								);
+								return file;
+							}
+						}),
+					)
+				: gen_result.files;
+
+			output_count += files.length;
+			return {
+				ok: true,
+				id,
+				files,
+				elapsed: timing_for_module(),
+			};
+		}),
+	);
+	return {
+		results,
+		successes: results.filter((r) => r.ok),
+		failures: results.filter((r) => !r.ok),
+		input_count,
+		output_count,
+		elapsed: timing_for_run_gen(),
+	};
+};

package/src/lib/run_task.test.ts

@@ -0,0 +1,86 @@
+import {test} from 'uvu';
+import * as assert from 'uvu/assert';
+import {Timings} from '@ryanatkn/belt/timings.js';
+
+import {run_task} from './run_task.js';
+import {load_config} from './config.js';
+
+test('passes args and returns output', async () => {
+	const args = {a: 1, _: []};
+	const result = await run_task(
+		{
+			name: 'testTask',
+			id: 'foo/testTask',
+			mod: {
+				task: {
+					run: ({args}) => Promise.resolve(args),
+				},
+			},
+		},
+		args,
+		() => Promise.resolve(),
+		await load_config(),
+		new Timings(),
+	);
+	assert.ok(result.ok);
+	assert.is(result.output, args);
+});
+
+test('invokes a sub task', async () => {
+	const args = {a: 1, _: []};
+	let invoked_task_name;
+	let invoked_args;
+	const result = await run_task(
+		{
+			name: 'testTask',
+			id: 'foo/testTask',
+			mod: {
+				task: {
+					run: async ({args, invoke_task}) => {
+						await invoke_task('bar/testTask', args);
+						return args;
+					},
+				},
+			},
+		},
+		args,
+		(invoking_task_name, invoking_args) => {
+			invoked_task_name = invoking_task_name;
+			invoked_args = invoking_args;
+			return Promise.resolve();
+		},
+		await load_config(),
+		new Timings(),
+	);
+	assert.ok(result.ok);
+	assert.is(invoked_task_name, 'bar/testTask');
+	assert.is(invoked_args, args);
+	assert.is(result.output, args);
+});
+
+test('failing task', async () => {
+	let err;
+	const result = await run_task(
+		{
+			name: 'testTask',
+			id: 'foo/testTask',
+			mod: {
+				task: {
+					run: () => {
+						err = Error();
+						throw err;
+					},
+				},
+			},
+		},
+		{_: []},
+		async () => {}, // eslint-disable-line @typescript-eslint/no-empty-function
+		await load_config(),
+		new Timings(),
+	);
+	assert.ok(!result.ok);
+	assert.ok(result.reason);
+	assert.is(result.error, err);
+});
+
+test.run();

package/src/lib/run_task.ts

@@ -0,0 +1,75 @@
+import {cyan, red} from '@ryanatkn/belt/styletext.js';
+import {print_log_label, System_Logger} from '@ryanatkn/belt/log.js';
+import type {Timings} from '@ryanatkn/belt/timings.js';
+
+import {parse_args, type Args} from './args.js';
+import type {invoke_task as base_invoke_task} from './invoke_task.js';
+import {log_task_help} from './task_logging.js';
+import type {Gro_Config} from './config.js';
+import {Task_Error, type Task_Module_Meta} from './task.js';
+import {sveltekit_config_global} from './sveltekit_config_global.js';
+
+export type Run_Task_Result =
+	| {
+			ok: true;
+			output: unknown;
+	  }
+	| {
+			ok: false;
+			reason: string;
+			error: Error;
+	  };
+
+export const run_task = async (
+	task_meta: Task_Module_Meta,
+	unparsed_args: Args,
+	invoke_task: typeof base_invoke_task,
+	config: Gro_Config,
+	timings: Timings,
+): Promise<Run_Task_Result> => {
+	const {task} = task_meta.mod;
+	const log = new System_Logger(print_log_label(task_meta.name));
+
+	if (unparsed_args.help) {
+		log_task_help(log, task_meta);
+		return {ok: true, output: null};
+	}
+
+	// Parse and validate args.
+	let args = unparsed_args;
+	if (task.Args) {
+		const parsed = parse_args(unparsed_args, task.Args);
+		if (!parsed.success) {
+			log.error(red(`Args validation failed:`), '\n', parsed.error.format());
+			throw new Task_Error(`Task args failed validation`);
+		}
+		args = parsed.data;
+	}
+
+	// Run the task.
+	let output: unknown;
+	try {
+		output = await task.run({
+			args,
+			config,
+			sveltekit_config: sveltekit_config_global,
+			log,
+			timings,
+			invoke_task: (invoked_task_name, invoked_args, invoked_config) =>
+				invoke_task(invoked_task_name, invoked_args, invoked_config ?? config, timings),
+		});
+	} catch (err) {
+		return {
+			ok: false,
+			reason: red(
+				err?.constructor?.name === 'Task_Error'
+					? (err.message as string)
+					: `Unexpected error running task ${cyan(
+							task_meta.name,
+						)}. If this is unexpected try running \`npm i\` and \`gro clean\`.`,
+			),
+			error: err,
+		};
+	}
+	return {ok: true, output};
+};

package/src/lib/search_fs.test.ts

@@ -0,0 +1,56 @@
+import {test} from 'uvu';
+import * as assert from 'uvu/assert';
+import {resolve} from 'node:path';
+
+import {search_fs} from './search_fs.js';
+
+test('search_fs basic behavior', () => {
+	const ignored_path = 'test1.foo.ts';
+	let has_ignored_path = false;
+	const result = search_fs('./src/fixtures', {
+		filter: (path) => {
+			if (!has_ignored_path) has_ignored_path = path.endsWith(ignored_path);
+			return !path.endsWith(ignored_path);
+		},
+		sort: (a, b) => a.path.localeCompare(b.path) * -1,
+	});
+	assert.ok(has_ignored_path); // makes sure the test isn't wrong
+	const expected_files = [
+		'test2.foo.ts',
+		'test_ts.ts',
+		'test_task_module.task_fixture.ts',
+		'test_js.js',
+		'test_invalid_task_module.ts',
+		'test_file.other.ext',
+		'test_failing_task_module.ts',
+		'some_test_side_effect.ts',
+		'some_test_json.json',
+		'some_test_exports3.ts',
+		'some_test_exports2.ts',
+		'some_test_exports.ts',
+		'modules/some_test_ts.ts',
+		'modules/Some_Test_Svelte.svelte',
+		'modules/some_test_svelte_ts.svelte.ts',
+		'modules/some_test_svelte_js.svelte.js',
+		'modules/some_test_server.ts',
+		'modules/some_test_json.json',
+		'modules/some_test_js.js',
+		'modules/some_test_css.css',
+		'changelog_example.md',
+		'changelog_cache.json',
+		'baz2/test2.baz.ts',
+		'baz1/test1.baz.ts',
+		'bar2/test2.bar.ts',
+		'bar1/test1.bar.ts',
+	];
+	assert.equal(
+		result.map((f) => f.path),
+		expected_files,
+	);
+	assert.equal(
+		result.map((f) => f.id),
+		expected_files.map((f) => resolve(`src/fixtures/${f}`)),
+	);
+});
+
+test.run();