@ryanatkn/gro 0.129.4 → 0.129.5

package/src/lib/git.ts

@@ -0,0 +1,297 @@
+import {spawn, spawn_out} from '@ryanatkn/belt/process.js';
+import type {SpawnOptions} from 'node:child_process';
+import {z} from 'zod';
+import {existsSync} from 'node:fs';
+
+import {to_file_path} from './path.js';
+
+// TODO maybe extract to `util-git`
+
+export const Git_Origin = z.string().brand('Git_Origin');
+export type Git_Origin = z.infer<typeof Git_Origin>;
+
+export const Git_Branch = z.string().brand('Git_Branch');
+export type Git_Branch = z.infer<typeof Git_Branch>;
+
+/**
+ * Returns the current git branch name or throws if something goes wrong.
+ */
+export const git_current_branch_name = async (options?: SpawnOptions): Promise<Git_Branch> => {
+	const {stdout} = await spawn_out('git', ['rev-parse', '--abbrev-ref', 'HEAD'], options);
+	if (!stdout) throw Error('git_current_branch_name failed');
+	const branch_name = stdout.toString().trim() as Git_Branch;
+	return branch_name;
+};
+
+/**
+ * @returns a boolean indicating if the remote git branch exists
+ */
+export const git_remote_branch_exists = async (
+	origin: Git_Origin = 'origin' as Git_Origin,
+	branch?: Git_Branch,
+	options?: SpawnOptions,
+): Promise<boolean> => {
+	const final_branch = branch ?? (await git_current_branch_name(options));
+	if (options?.cwd && !existsSync(to_file_path(options.cwd))) {
+		return false;
+	}
+	const result = await spawn(
+		'git',
+		['ls-remote', '--exit-code', '--heads', origin, 'refs/heads/' + final_branch],
+		options,
+	);
+	if (result.ok) {
+		return true;
+	} else if (result.code === 2) {
+		return false;
+	} else {
+		throw Error(
+			`git_remote_branch_exists failed for origin '${origin}' and branch '${final_branch}' with code ${result.code}`,
+		);
+	}
+};
+
+/**
+ * @returns a boolean indicating if the local git branch exists
+ */
+export const git_local_branch_exists = async (
+	branch: Git_Branch,
+	options?: SpawnOptions,
+): Promise<boolean> => {
+	if (options?.cwd && !existsSync(to_file_path(options.cwd))) {
+		return false;
+	}
+	const result = await spawn('git', ['show-ref', '--quiet', 'refs/heads/' + branch], options);
+	return result.ok;
+};
+
+/**
+ * TODO make this return an enum and separate the text into a different function
+ * @returns an error message if the git workspace has any unstaged or uncommitted changes, or `null` if it's clean
+ */
+export const git_check_clean_workspace = async (options?: SpawnOptions): Promise<string | null> => {
+	const unstaged_result = await spawn('git', ['diff', '--exit-code', '--quiet'], options);
+	if (!unstaged_result.ok) {
+		return 'git has unstaged changes';
+	}
+	const staged_result = await spawn('git', ['diff', '--exit-code', '--cached', '--quiet'], options);
+	if (!staged_result.ok) {
+		return 'git has staged but uncommitted changes';
+	}
+	const status_result = await spawn_out('git', ['status', '--porcelain'], options);
+	if (status_result.stdout?.length) {
+		return 'git has untracked files';
+	}
+	return null;
+};
+
+/**
+ * TODO make this return an enum and separate the text into a different function
+ * @returns an error message if the git workspace has any unstaged stages, or `null` if it's clean
+ */
+export const git_check_fully_staged_workspace = async (
+	options?: SpawnOptions,
+): Promise<string | null> => {
+	const unstaged_result = await spawn('git', ['diff', '--exit-code', '--quiet'], options);
+	if (!unstaged_result.ok) {
+		return 'git has unstaged changes';
+	}
+	const status_result = await spawn_out('git', ['status', '--porcelain'], options);
+	if (status_result.stdout?.includes('??')) {
+		return 'git has untracked files';
+	}
+	return null;
+};
+
+/**
+ * Calls `git fetch` and throws if anything goes wrong.
+ */
+export const git_fetch = async (
+	origin: Git_Origin = 'origin' as Git_Origin,
+	branch?: Git_Branch,
+	options?: SpawnOptions,
+): Promise<void> => {
+	const args = ['fetch', origin];
+	if (branch) args.push(branch);
+	const result = await spawn('git', args, options);
+	if (!result.ok) {
+		throw Error(
+			`git_fetch failed for origin '${origin}' and branch '${branch}' with code ${result.code}`,
+		);
+	}
+};
+
+/**
+ * Calls `git checkout` and throws if anything goes wrong.
+ * @returns the previous branch name, if it changed
+ */
+export const git_checkout = async (
+	branch: Git_Branch,
+	options?: SpawnOptions,
+): Promise<Git_Branch | null> => {
+	const current_branch = await git_current_branch_name(options);
+	if (branch === current_branch) {
+		return null;
+	}
+	const result = await spawn('git', ['checkout', branch], options);
+	if (!result.ok) {
+		throw Error(`git_checkout failed for branch '${branch}' with code ${result.code}`);
+	}
+	return current_branch;
+};
+
+/**
+ * Calls `git pull` and throws if anything goes wrong.
+ */
+export const git_pull = async (
+	origin: Git_Origin = 'origin' as Git_Origin,
+	branch?: Git_Branch,
+	options?: SpawnOptions,
+): Promise<void> => {
+	const args = ['pull', origin];
+	if (branch) args.push(branch);
+	const result = await spawn('git', args, options);
+	if (!result.ok) {
+		throw Error(`git_pull failed for branch '${branch}' with code ${result.code}`);
+	}
+};
+
+/**
+ * Calls `git push` and throws if anything goes wrong.
+ */
+export const git_push = async (
+	origin: Git_Origin,
+	branch?: Git_Branch,
+	options?: SpawnOptions,
+	set_upstream = false,
+): Promise<void> => {
+	const final_branch = branch ?? (await git_current_branch_name(options));
+	const args = ['push', origin, final_branch];
+	if (set_upstream) args.push('-u');
+	const result = await spawn('git', args, options);
+	if (!result.ok) {
+		throw Error(`git_push failed for branch '${final_branch}' with code ${result.code}`);
+	}
+};
+
+/**
+ * Calls `git push` and throws if anything goes wrong.
+ */
+export const git_push_to_create = async (
+	origin: Git_Origin = 'origin' as Git_Origin,
+	branch?: Git_Branch,
+	options?: SpawnOptions,
+): Promise<void> => {
+	const final_branch = branch ?? (await git_current_branch_name(options));
+	const push_args = ['push'];
+	if (await git_remote_branch_exists(origin, final_branch, options)) {
+		push_args.push(origin);
+	} else {
+		push_args.push('-u', origin);
+	}
+	push_args.push(final_branch);
+	const result = await spawn('git', push_args, options);
+	if (!result.ok) {
+		throw Error(`git_push failed for branch '${final_branch}' with code ${result.code}`);
+	}
+};
+
+/**
+ * Deletes a branch locally and throws if anything goes wrong.
+ */
+export const git_delete_local_branch = async (
+	branch: Git_Branch,
+	options?: SpawnOptions,
+): Promise<void> => {
+	const result = await spawn('git', ['branch', '-D', branch], options);
+	if (!result.ok) {
+		throw Error(`git_delete_local_branch failed for branch '${branch}' with code ${result.code}`);
+	}
+};
+
+/**
+ * Deletes a branch remotely and throws if anything goes wrong.
+ */
+export const git_delete_remote_branch = async (
+	origin: Git_Origin,
+	branch: Git_Branch,
+	options?: SpawnOptions,
+): Promise<void> => {
+	const result = await spawn('git', ['push', origin, ':' + branch], options);
+	if (!result.ok) {
+		throw Error(`git_delete_remote_branch failed for branch '${branch}' with code ${result.code}`);
+	}
+};
+
+/**
+ * Resets the `target` branch back to its first commit both locally and remotely.
+ */
+export const git_reset_branch_to_first_commit = async (
+	origin: Git_Origin,
+	branch: Git_Branch,
+	options?: SpawnOptions,
+): Promise<void> => {
+	const previous_branch = await git_checkout(branch, options);
+	const first_commit_hash = await git_current_branch_first_commit_hash(options);
+	await spawn('git', ['reset', '--hard', first_commit_hash], options);
+	await spawn('git', ['push', origin, branch, '--force'], options);
+	if (previous_branch) {
+		await git_checkout(previous_branch, options);
+	}
+};
+
+/**
+ * Returns the branch's latest commit hash or throws if something goes wrong.
+ */
+export const git_current_commit_hash = async (
+	branch?: string,
+	options?: SpawnOptions,
+): Promise<string | null> => {
+	const final_branch = branch ?? (await git_current_branch_name(options));
+	const {stdout} = await spawn_out('git', ['show-ref', '-s', final_branch], options);
+	if (!stdout) return null; // TODO hack for CI
+	return stdout.toString().split('\n')[0].trim();
+};
+
+/**
+ * Returns the hash of the current branch's first commit or throws if something goes wrong.
+ */
+export const git_current_branch_first_commit_hash = async (
+	options?: SpawnOptions,
+): Promise<string> => {
+	const {stdout} = await spawn_out(
+		'git',
+		['rev-list', '--max-parents=0', '--abbrev-commit', 'HEAD'],
+		options,
+	);
+	if (!stdout) throw Error('git_current_branch_first_commit_hash failed');
+	return stdout.toString().trim();
+};
+
+/**
+ * Returns the global git config setting for `pull.rebase`.
+ * Gro is currently written to expect `true`,
+ * but the restriction could be loosened with additional work.
+ */
+export const git_check_setting_pull_rebase = async (options?: SpawnOptions): Promise<boolean> => {
+	const value = await spawn_out('git', ['config', '--global', 'pull.rebase'], options);
+	return value.stdout?.trim() === 'true';
+};
+
+/**
+ * Clones a branch locally to another directory and updates the origin to match the source.
+ */
+export const git_clone_locally = async (
+	origin: Git_Origin,
+	branch: Git_Branch,
+	source_dir: string,
+	target_dir: string,
+	options?: SpawnOptions,
+): Promise<void> => {
+	await spawn('git', ['clone', '-b', branch, '--single-branch', source_dir, target_dir], options);
+	const origin_url = (
+		await spawn_out('git', ['remote', 'get-url', origin], {...options, cwd: source_dir})
+	).stdout?.trim();
+	if (!origin_url) throw Error('Failed to get the origin url with git in ' + source_dir);
+	await spawn('git', ['remote', 'set-url', origin, origin_url], {...options, cwd: target_dir});
+};

package/src/lib/github.ts

@@ -0,0 +1,46 @@
+// TODO if this grows at all, use `@octokit/request`,
+// for now it's just calling a single endpoint so we do it manually
+// and we specify just the types we need
+
+import {Fetch_Value_Cache, fetch_value} from '@ryanatkn/belt/fetch.js';
+import type {Logger} from '@ryanatkn/belt/log.js';
+import {z} from 'zod';
+
+export const GITHUB_REPO_MATCHER = /.+github.com\/(.+)\/(.+)/u;
+
+export const Github_Pull_Request = z.object({
+	url: z.string(),
+	id: z.number(),
+	html_url: z.string(),
+	number: z.number(),
+	user: z.object({
+		login: z.string(),
+	}),
+});
+export type Github_Pull_Request = z.infer<typeof Github_Pull_Request>;
+
+/**
+ * @see https://docs.github.com/en/rest/commits/commits?apiVersion=2022-11-28#list-pull-requests-associated-with-a-commit
+ */
+export const github_fetch_commit_prs = async (
+	owner: string,
+	repo: string,
+	commit_sha: string,
+	token?: string,
+	log?: Logger,
+	cache?: Fetch_Value_Cache,
+	api_version?: string,
+): Promise<Github_Pull_Request[] | null> => {
+	const headers = api_version ? new Headers({'x-github-api-version': api_version}) : undefined;
+	const url = `https://api.github.com/repos/${owner}/${repo}/commits/${commit_sha}/pulls`;
+	const fetched = await fetch_value(url, {
+		request: {headers},
+		parse: (v: any[]) => v.map((p) => Github_Pull_Request.parse(p)),
+		token,
+		cache,
+		return_early_from_cache: true,
+		log,
+	});
+	if (!fetched.ok) return null;
+	return fetched.value;
+};

package/src/lib/gro.config.default.ts

@@ -0,0 +1,34 @@
+import type {Create_Gro_Config} from './config.js';
+import {gro_plugin_sveltekit_library} from './gro_plugin_sveltekit_library.js';
+import {has_server, gro_plugin_server} from './gro_plugin_server.js';
+import {gro_plugin_sveltekit_app} from './gro_plugin_sveltekit_app.js';
+import {has_sveltekit_app, has_sveltekit_library} from './sveltekit_helpers.js';
+
+/**
+ * This is the default config that's passed to `gro.config.ts`
+ * if it exists in the current project, and if not, this is the final config.
+ * It looks at the project and tries to do the right thing:
+ *
+ * - if `src/routes`, assumes a SvelteKit frontend
+ * - if `src/lib`, assumes a Node library
+ * - if `src/lib/server/server.ts`, assumes a Node server
+ */
+const config: Create_Gro_Config = async (cfg) => {
+	const [has_sveltekit_library_result, has_server_result, has_sveltekit_app_result] =
+		await Promise.all([has_sveltekit_library(), has_server(), has_sveltekit_app()]);
+
+	cfg.plugins = () => [
+		has_sveltekit_library_result.ok ? gro_plugin_sveltekit_library() : null,
+		has_server_result.ok ? gro_plugin_server() : null,
+		has_sveltekit_app_result.ok
+			? gro_plugin_sveltekit_app({host_target: has_server_result.ok ? 'node' : 'github_pages'})
+			: null,
+		// TODO replace with an esbuild plugin, see the module for more
+		// import {gro_plugin_gen} from './gro_plugin_gen.js';
+		// gro_plugin_gen(),
+	];
+
+	return cfg;
+};
+
+export default config;

package/src/lib/gro.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+import {join} from 'node:path';
+
+import {resolve_gro_module_path, spawn_with_loader} from './gro_helpers.js';
+
+/*
+
+This file is a loader for the Gro CLI.
+Its only purpose is to import the `invoke.js` script in the correct directory.
+By using `resolve_gro_module_path` it lets the global Gro CLI defer
+to a local installation of Gro if one is available,
+and it also provides special handling for the case
+where we're running Gro inside Gro's own repo for development.
+
+*/
+
+const invoke_path = resolve_gro_module_path('invoke.js');
+
+const loader_path = join(invoke_path, '../loader.js');
+
+const spawned = await spawn_with_loader(loader_path, invoke_path, process.argv.slice(2));
+if (!spawned.ok) {
+	process.exit(spawned.code || 1); // eslint-disable-line @typescript-eslint/prefer-nullish-coalescing
+}

package/src/lib/gro_helpers.ts

@@ -0,0 +1,101 @@
+import {realpathSync, existsSync} from 'node:fs';
+import {join, resolve} from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {spawn, type Spawn_Result} from '@ryanatkn/belt/process.js';
+
+import {NODE_MODULES_DIRNAME, SVELTEKIT_DIST_DIRNAME} from './path_constants.js';
+
+/*
+
+This module is intended to have minimal dependencies to avoid over-imports in the CLI.
+
+*/
+
+/**
+ * Resolves a path to an internal Gro file.
+ * Prefers any local installation of Gro and falls back to the current CLI context.
+ *
+ * Uses heuristics to find `path`, so may fail in some rare corner cases.
+ * Currently looks for `gro.js` as a sibling to the `path` arg for detection.
+ * If this fails for your usecases, rename `gro.js` or open an issue/PR!
+ *
+ * Used by the CLI and `gro run`.
+ *
+ * case 1:
+ *
+ * We're in a directory that has a local installation of Gro at `node_modules/.bin/gro`.
+ * Use this local version instead of the global.
+ *
+ * case 2:
+ *
+ * We're running Gro inside the Gro repo itself.
+ *
+ * In this case, we use the build directory instead of dist.
+ * There's a paradox here for using Gro inside itself -
+ * ideally we use the dist directory because that's what's shipped,
+ * but the build directory has all of the tests,
+ * and loading two instances of its modules causes problems
+ * like `instanceof` checks failing.
+ * For now we'll just run from build and see if it causes any problems.
+ * There's probably a better design in here somewhere.
+ *
+ * case 3:
+ *
+ * Fall back to invoking Gro from wherever the CLI is being executed.
+ * When using the global CLI, this uses the global Gro installation.
+ *
+ */
+export const resolve_gro_module_path = (path = ''): string => {
+	const gro_bin_path = resolve(NODE_MODULES_DIRNAME, '.bin/gro');
+	// case 1
+	// Prefer any locally installed version of Gro.
+	if (existsSync(gro_bin_path)) {
+		return join(realpathSync(gro_bin_path), '..', path);
+	}
+	// case 2
+	// If running Gro inside its own repo, require the local dist.
+	// If the local dist is not yet built it will fall back to the global.
+	if (
+		existsSync(join(SVELTEKIT_DIST_DIRNAME, 'gro.js')) &&
+		existsSync(join(SVELTEKIT_DIST_DIRNAME, path))
+	) {
+		return resolve(SVELTEKIT_DIST_DIRNAME, path);
+	}
+	// case 3
+	// Fall back to the version associated with the running CLI.
+	const file_path = fileURLToPath(import.meta.url);
+	return join(file_path, '..', path);
+};
+
+/**
+ * Runs a file using the Gro loader.
+ *
+ * Uses conditional exports to correctly set up `esm-env` as development by default,
+ * so if you want production set `NODE_ENV=production`.
+ *
+ * @see https://nodejs.org/api/packages.html#conditional-exports
+ *
+ * @param loader_path path to loader
+ * @param invoke_path path to file to spawn with `node`
+ */
+export const spawn_with_loader = (
+	loader_path: string,
+	invoke_path: string,
+	argv: string[],
+): Promise<Spawn_Result> => {
+	const args = [
+		'--import',
+		// This does the same as `$lib/register.ts` but without the cost of importing another file.
+		`data:text/javascript,
+			import {register} from "node:module";
+			import {pathToFileURL} from "node:url";
+			register("${loader_path}", pathToFileURL("./"));`,
+		'--enable-source-maps', // because TypeScript
+	];
+	// In almost all cases we want the exports condition to be `"development"`.
+	if (process.env.NODE_ENV !== 'production') {
+		args.push('-C', 'development'); // same as `--conditions`
+	}
+	args.push(invoke_path, ...argv);
+	return spawn('node', args);
+};

package/src/lib/gro_plugin_gen.ts

@@ -0,0 +1,95 @@
+// TODO this became unused with https://github.com/ryanatkn/gro/pull/382
+// because we no longer have a normal system build - replace with an esbuild plugin
+// @ts-nocheck
+
+import type {Plugin, Plugin_Context} from './plugin.js';
+import type {Args} from './args.js';
+import {path_id_to_base_path} from './paths.js';
+import {find_genfiles, is_gen_path} from './gen.js';
+import {filter_dependents} from './build/source_file.js';
+import {throttle} from './throttle.js';
+
+const FLUSH_DEBOUNCE_DELAY = 500;
+
+export interface Task_Args extends Args {
+	watch?: boolean;
+}
+
+export const plugin = (): Plugin<Plugin_Context<Task_Args>> => {
+	let generating = false;
+	let regen = false;
+	let on_filer_build: ((e: Filer_Events['build']) => void) | undefined;
+	const queued_files: Set<string> = new Set();
+	const queue_gen = (gen_file_name: string) => {
+		queued_files.add(gen_file_name);
+		void flush_gen_queue();
+	};
+	const flush_gen_queue = throttle(async () => {
+		// hacky way to avoid concurrent `gro gen` calls
+		if (generating) {
+			regen = true;
+			return;
+		}
+		generating = true;
+		const files = Array.from(queued_files);
+		queued_files.clear();
+		await gen(files);
+		generating = false;
+		if (regen) {
+			regen = false;
+			void flush_gen_queue();
+		}
+	}, FLUSH_DEBOUNCE_DELAY);
+	const gen = (files: string[] = []) => spawn_cli('gro', ['gen', ...files]);
+
+	return {
+		name: 'gro_plugin_gen',
+		setup: async ({args: {watch}, dev, log, config}) => {
+			// For production builds, we assume `gen` is already fresh,
+			// which should be checked by CI via `gro check` which calls `gro gen --check`.
+			if (!dev) return;
+
+			// Run `gen`, first checking if there are any modules to avoid a console error.
+			// Some parts of the build may have already happened,
+			// making us miss `build` events for gen dependencies,
+			// so we run `gen` here even if it's usually wasteful.
+			const found = find_genfiles([paths.source], root_dirs, config);
+			if (found.ok && found.value.resolved_input_files.size > 0) {
+				await gen();
+			}
+
+			// Do we need to just generate everything once and exit?
+			// TODO could we have an esbuild context here? problem is watching the right files, maybe a plugin that tracks deps
+			if (!filer || !watch) {
+				log.info('generating and exiting early');
+				return;
+			}
+
+			// When a file builds, check it and its tree of dependents
+			// for any `.gen.` files that need to run.
+			on_filer_build = ({source_file, build_config}) => {
+				// TODO how to handle this now? the loader traces deps for us with `parentPath`,
+				// but we probably want to make this an esbuild plugin instead
+				// if (build_config.name !== 'system') return;
+				if (is_gen_path(source_file.id)) {
+					queue_gen(path_id_to_base_path(source_file.id));
+				}
+				const dependent_gen_file_ids = filter_dependents(
+					source_file,
+					build_config,
+					filer.find_by_id as any, // cast because we can assume they're all `SourceFile`s
+					is_gen_path,
+				);
+				for (const dependent_gen_file_id of dependent_gen_file_ids) {
+					queue_gen(path_id_to_base_path(dependent_gen_file_id));
+				}
+			};
+			filer.on('build', on_filer_build);
+		},
+		teardown: ({filer}) => {
+			if (on_filer_build && filer) {
+				filer.off('build', on_filer_build);
+			}
+		},
+	};
+};