@ryanatkn/gro 0.129.4 → 0.129.6

package/src/lib/changeset.task.ts

@@ -0,0 +1,206 @@
+import {z} from 'zod';
+import {spawn} from '@ryanatkn/belt/process.js';
+import {red, blue} from '@ryanatkn/belt/styletext.js';
+import type {WrittenConfig} from '@changesets/types';
+import {readFile, writeFile} from 'node:fs/promises';
+import {join} from 'node:path';
+import {existsSync, readdirSync} from 'node:fs';
+
+import {Task_Error, type Task} from './task.js';
+import {find_cli, spawn_cli} from './cli.js';
+import {Git_Origin, git_check_fully_staged_workspace, git_push_to_create} from './git.js';
+import {has_sveltekit_library} from './sveltekit_helpers.js';
+import {
+	CHANGESET_CLI,
+	CHANGESET_DIR,
+	Changeset_Access,
+	Changeset_Bump,
+	CHANGESET_PUBLIC_ACCESS,
+	CHANGESET_RESTRICTED_ACCESS,
+} from './changeset_helpers.js';
+import {load_package_json} from './package_json.js';
+
+export const Args = z
+	.object({
+		/**
+		 * The optional rest args get joined with a space to form the `message`.
+		 */
+		_: z.array(z.string(), {description: 'the message for the changeset and commit'}).default([]),
+		minor: z.boolean({description: 'bump the minor version'}).default(false),
+		major: z.boolean({description: 'bump the major version'}).default(false),
+		dir: z.string({description: 'changeset dir'}).default(CHANGESET_DIR),
+		access: Changeset_Access.describe(
+			"changeset 'access' config value, the default depends on package.json#private",
+		).optional(),
+		changelog: z
+			.string({description: 'changeset "changelog" config value'})
+			.default('@changesets/changelog-git'),
+		install: z.boolean({description: 'dual of no-install'}).default(true),
+		'no-install': z
+			.boolean({description: 'opt out of npm installing the changelog package'})
+			.default(false),
+		origin: Git_Origin.describe('git origin to deploy to').default('origin'),
+		changeset_cli: z.string({description: 'the changeset CLI to use'}).default(CHANGESET_CLI),
+	})
+	.strict();
+export type Args = z.infer<typeof Args>;
+
+/**
+ * Calls the `changeset` CLI with some simple automations.
+ * This API is designed for convenient manual usage, not clarity or normality.
+ *
+ * Usage:
+ * - gro changeset some commit message
+ * - gro changeset some commit message --minor
+ * - gro changeset "some commit message" --minor
+ */
+export const task: Task<Args> = {
+	summary: 'call changeset with gro patterns',
+	Args,
+	run: async (ctx): Promise<void> => {
+		const {
+			invoke_task,
+			args: {_, minor, major, dir, access: access_arg, changelog, install, origin, changeset_cli},
+			log,
+			sveltekit_config,
+		} = ctx;
+
+		const message = _.join(' ');
+
+		if (!message && (minor || major)) throw new Task_Error('cannot bump version without a message');
+		if (minor && major) throw new Task_Error('cannot bump both minor and major');
+
+		const bump: Changeset_Bump = minor ? 'minor' : major ? 'major' : 'patch';
+
+		const found_changeset_cli = find_cli(changeset_cli);
+		if (!found_changeset_cli) {
+			throw new Task_Error(
+				'changeset command not found: install @changesets/cli locally or globally',
+			);
+		}
+
+		const package_json = load_package_json();
+
+		const has_sveltekit_library_result = has_sveltekit_library(package_json, sveltekit_config);
+		if (!has_sveltekit_library_result.ok) {
+			throw new Task_Error(
+				'Failed to find SvelteKit library: ' + has_sveltekit_library_result.message,
+			);
+		}
+
+		const path = join(dir, 'config.json');
+
+		const inited = existsSync(path);
+
+		if (!inited) {
+			await spawn_cli(found_changeset_cli, ['init'], log);
+
+			const access =
+				access_arg ?? package_json.private ? CHANGESET_RESTRICTED_ACCESS : CHANGESET_PUBLIC_ACCESS;
+
+			const access_color = access === CHANGESET_RESTRICTED_ACCESS ? blue : red;
+			log.info('initing changeset with ' + access_color(access) + ' access');
+			if (access !== CHANGESET_RESTRICTED_ACCESS) {
+				await update_changeset_config(path, (config) => {
+					const updated = {...config};
+					updated.access = access;
+					updated.changelog = changelog;
+					return updated;
+				});
+			}
+
+			await spawn('git', ['add', dir]);
+
+			if (install) {
+				await spawn('npm', ['i', '-D', changelog]);
+			}
+		}
+
+		// TODO small problem here where generated files don't get committed
+		await invoke_task('sync'); // after the `npm i` above, and in all cases
+
+		if (message) {
+			// TODO see the helper below, simplify this to CLI flags when support is added to Changesets
+			const changeset_adder = create_changeset_adder(package_json.name, dir, message, bump);
+			await spawn_cli(found_changeset_cli, ['add', '--empty'], log);
+			await changeset_adder();
+			if (!(await git_check_fully_staged_workspace())) {
+				await spawn('git', ['commit', '-m', message]);
+				await git_push_to_create(origin);
+			}
+		} else {
+			await spawn_cli(found_changeset_cli, [], log);
+			await spawn('git', ['add', dir]);
+		}
+	},
+};
+
+/**
+ * TODO ideally this wouldn't exist and we'd use CLI flags, but they doesn't exist yet
+ * @see https://github.com/changesets/changesets/pull/1121
+ */
+const create_changeset_adder = (
+	repo_name: string,
+	dir: string,
+	message: string,
+	bump: Changeset_Bump,
+) => {
+	const filenames_before = readdirSync(dir);
+	return async () => {
+		const filenames_after = readdirSync(dir);
+		const filenames_added = filenames_after.filter((p) => !filenames_before.includes(p));
+		if (!filenames_added.length) {
+			throw Error('expected to find a new changeset file');
+		}
+		if (filenames_added.length !== 1) {
+			throw Error('expected to find exactly one new changeset file');
+		}
+		const path = join(dir, filenames_added[0]);
+		const contents = create_new_changeset(repo_name, message, bump);
+		await writeFile(path, contents, 'utf8');
+		await spawn('git', ['add', path]);
+	};
+};
+
+const create_new_changeset = (
+	repo_name: string,
+	message: string,
+	bump: Changeset_Bump,
+): string => `---
+"${repo_name}": ${bump}
+---
+
+${message}
+`;
+
+type Changeset_Callback = (config: WrittenConfig) => WrittenConfig | Promise<WrittenConfig>;
+
+type Update_Written_Config = (path: string, cb: Changeset_Callback) => Promise<boolean>;
+
+// TODO refactor all of this with zod and package_json helpers - util file helper? JSON parse pluggable
+
+const update_changeset_config: Update_Written_Config = async (path, cb) => {
+	const config_contents = await load_changeset_config_contents(path);
+	const config = parse_changeset_config(config_contents);
+
+	const updated = await cb(config);
+
+	const serialized = serialize_changeset_config(updated);
+
+	if (serialized === config_contents) {
+		return false;
+	}
+
+	await write_changeset_config(path, serialized);
+	return true;
+};
+
+const load_changeset_config_contents = (path: string): Promise<string> => readFile(path, 'utf8');
+
+const write_changeset_config = (path: string, serialized: string): Promise<void> =>
+	writeFile(path, serialized);
+
+const serialize_changeset_config = (config: WrittenConfig): string =>
+	JSON.stringify(config, null, '\t') + '\n';
+
+const parse_changeset_config = (contents: string): WrittenConfig => JSON.parse(contents);

package/src/lib/changeset_helpers.ts

@@ -0,0 +1,13 @@
+import {z} from 'zod';
+
+export const CHANGESET_RESTRICTED_ACCESS = 'restricted';
+export const CHANGESET_PUBLIC_ACCESS = 'public';
+
+export const Changeset_Access = z.enum([CHANGESET_RESTRICTED_ACCESS, CHANGESET_PUBLIC_ACCESS]);
+
+export const CHANGESET_CLI = 'changeset';
+
+export const CHANGESET_DIR = '.changeset';
+
+export const Changeset_Bump = z.enum(['patch', 'minor', 'major']);
+export type Changeset_Bump = z.infer<typeof Changeset_Bump>;

package/src/lib/check.task.ts

@@ -0,0 +1,90 @@
+import {z} from 'zod';
+import {spawn} from '@ryanatkn/belt/process.js';
+import {red} from '@ryanatkn/belt/styletext.js';
+
+import {Task_Error, type Task} from './task.js';
+import {git_check_clean_workspace} from './git.js';
+import {sync_package_json} from './package_json.js';
+
+export const Args = z
+	.object({
+		typecheck: z.boolean({description: 'dual of no-typecheck'}).default(true),
+		'no-typecheck': z.boolean({description: 'opt out of typechecking'}).default(false),
+		test: z.boolean({description: 'dual of no-test'}).default(true),
+		'no-test': z.boolean({description: 'opt out of running tests'}).default(false),
+		gen: z.boolean({description: 'dual of no-gen'}).default(true),
+		'no-gen': z.boolean({description: 'opt out of gen check'}).default(false),
+		format: z.boolean({description: 'dual of no-format'}).default(true),
+		'no-format': z.boolean({description: 'opt out of format check'}).default(false),
+		package_json: z.boolean({description: 'dual of no-package_json'}).default(true),
+		'no-package_json': z.boolean({description: 'opt out of package.json check'}).default(false),
+		lint: z.boolean({description: 'dual of no-lint'}).default(true),
+		'no-lint': z.boolean({description: 'opt out of linting'}).default(false),
+		workspace: z
+			.boolean({description: 'ensure a clean git workspace, useful for CI'})
+			.default(false),
+	})
+	.strict();
+export type Args = z.infer<typeof Args>;
+
+export const task: Task<Args> = {
+	summary: 'check that everything is ready to commit',
+	Args,
+	run: async ({args, invoke_task, log, config}) => {
+		const {typecheck, test, gen, format, package_json, lint, workspace} = args;
+
+		// When checking the workspace, which was added for CI,
+		// don't sync, because the check will fail with misleading errors.
+		// For example it would cause the gen check to be a false negative,
+		// and then the workspace check would fail with the new files.
+		const sync = !workspace;
+		if (sync) {
+			await invoke_task('sync');
+		}
+
+		if (typecheck) {
+			await invoke_task('typecheck');
+		}
+
+		if (test) {
+			await invoke_task('test');
+		}
+
+		if (gen) {
+			await invoke_task('gen', {check: true});
+		}
+
+		if (package_json && config.map_package_json) {
+			const {changed} = await sync_package_json(config.map_package_json, log, true);
+			if (changed) {
+				throw new Task_Error('package.json is out of date, run `gro sync` to update it');
+			} else {
+				log.info('check passed for package.json');
+			}
+		}
+
+		if (format) {
+			await invoke_task('format', {check: true});
+		}
+
+		// Run the linter last to surface every other kind of problem first.
+		// It's not the ideal order when the linter would catch errors that cause failing tests,
+		// but it's better for most usage.
+		if (lint) {
+			await invoke_task('lint');
+		}
+
+		if (workspace) {
+			const error_message = await git_check_clean_workspace();
+			if (error_message) {
+				log.error(red('git status'));
+				await spawn('git', ['status']);
+				throw new Task_Error(
+					'Failed check for git_check_clean_workspace:' +
+						error_message +
+						' - do you need to run `gro sync` or commit some files?',
+				);
+			}
+		}
+	},
+};

package/src/lib/clean.task.ts

@@ -0,0 +1,46 @@
+import {spawn} from '@ryanatkn/belt/process.js';
+import {z} from 'zod';
+
+import type {Task} from './task.js';
+import {clean_fs} from './clean_fs.js';
+import {Git_Origin} from './git.js';
+
+export const Args = z
+	.object({
+		build_dev: z.boolean({description: 'delete the Gro build dev directory'}).default(false),
+		build_dist: z.boolean({description: 'delete the Gro build dist directory'}).default(false),
+		sveltekit: z
+			.boolean({description: 'delete the SvelteKit directory and Vite cache'})
+			.default(false),
+		nodemodules: z.boolean({description: 'delete the node_modules directory'}).default(false),
+		git: z
+			.boolean({
+				description:
+					'run "git remote prune" to delete local branches referencing nonexistent remote branches',
+			})
+			.default(false),
+		git_origin: Git_Origin.describe('the origin to "git remote prune"').default('origin'),
+	})
+	.strict();
+export type Args = z.infer<typeof Args>;
+
+export const task: Task<Args> = {
+	summary: 'remove temporary dev and build files, and optionally prune git branches',
+	Args,
+	run: async ({args}): Promise<void> => {
+		const {build_dev, build_dist, sveltekit, nodemodules, git, git_origin} = args;
+
+		await clean_fs({
+			build: !build_dev && !build_dist,
+			build_dev,
+			build_dist,
+			sveltekit,
+			nodemodules,
+		});
+
+		// lop off stale git branches
+		if (git) {
+			await spawn('git', ['remote', 'prune', git_origin]);
+		}
+	},
+};

package/src/lib/clean_fs.ts

@@ -0,0 +1,54 @@
+import {rm} from 'node:fs/promises';
+import {readdirSync, type RmOptions} from 'node:fs';
+
+import {paths} from './paths.js';
+import {
+	NODE_MODULES_DIRNAME,
+	GRO_DIST_PREFIX,
+	SVELTEKIT_DEV_DIRNAME,
+	SVELTEKIT_BUILD_DIRNAME,
+	SVELTEKIT_VITE_CACHE_PATH,
+	SVELTEKIT_DIST_DIRNAME,
+} from './path_constants.js';
+
+export const clean_fs = async (
+	{
+		build = false,
+		build_dev = false,
+		build_dist = false,
+		sveltekit = false,
+		nodemodules = false,
+	}: {
+		build?: boolean;
+		build_dev?: boolean;
+		build_dist?: boolean;
+		sveltekit?: boolean;
+		nodemodules?: boolean;
+	},
+	rm_options: RmOptions = {force: true, recursive: true},
+): Promise<void> => {
+	const promises: Array<Promise<void>> = [];
+
+	if (build) {
+		promises.push(rm(paths.build, rm_options));
+	} else if (build_dev) {
+		promises.push(rm(paths.build_dev, rm_options));
+	}
+	if (build || build_dist) {
+		const paths = readdirSync('.').filter((p) => p.startsWith(GRO_DIST_PREFIX));
+		for (const path of paths) {
+			promises.push(rm(path, rm_options));
+		}
+	}
+	if (sveltekit) {
+		promises.push(rm(SVELTEKIT_DEV_DIRNAME, rm_options));
+		promises.push(rm(SVELTEKIT_BUILD_DIRNAME, rm_options));
+		promises.push(rm(SVELTEKIT_DIST_DIRNAME, rm_options));
+		promises.push(rm(SVELTEKIT_VITE_CACHE_PATH, rm_options));
+	}
+	if (nodemodules) {
+		promises.push(rm(NODE_MODULES_DIRNAME, rm_options));
+	}
+
+	await Promise.all(promises);
+};

package/src/lib/cli.ts

@@ -0,0 +1,97 @@
+import {spawnSync, type SpawnOptions} from 'node:child_process';
+import {
+	spawn,
+	spawn_process,
+	type Spawn_Result,
+	type Spawned_Process,
+} from '@ryanatkn/belt/process.js';
+import {join} from 'node:path';
+import {existsSync} from 'node:fs';
+import {fileURLToPath} from 'node:url';
+import type {Logger} from '@ryanatkn/belt/log.js';
+
+import {NODE_MODULES_DIRNAME} from './path_constants.js';
+import type {Path_Id} from './path.js';
+import {print_command_args} from './args.js';
+
+// TODO maybe upstream to Belt?
+
+export type Cli =
+	| {kind: 'local'; name: string; id: Path_Id}
+	| {kind: 'global'; name: string; id: Path_Id};
+
+/**
+ * Searches the filesystem for the CLI `name`, first local to the cwd and then globally.
+ * @returns `null` if not found locally or globally
+ */
+export const find_cli = (
+	name: string,
+	cwd: string | URL = process.cwd(),
+	options?: SpawnOptions | undefined,
+): Cli | null => {
+	const final_cwd = typeof cwd === 'string' ? cwd : fileURLToPath(cwd);
+	const local_id = join(final_cwd, NODE_MODULES_DIRNAME, `.bin/${name}`);
+	if (existsSync(local_id)) {
+		return {name, id: local_id, kind: 'local'};
+	}
+	const {stdout} = spawnSync('which', [name], options);
+	const global_id = stdout.toString().trim();
+	if (!global_id) return null;
+	return {name, id: global_id, kind: 'global'};
+};
+
+/**
+ * Spawns a CLI if available using Belt's `spawn`.
+ * If a string is provided for `name_or_cli`, it checks first local to the cwd and then globally.
+ * @returns `undefined` if no CLI is found, or the spawn result
+ */
+export const spawn_cli = async (
+	name_or_cli: string | Cli,
+	args: string[] = [],
+	log?: Logger,
+	options?: SpawnOptions | undefined,
+): Promise<Spawn_Result | undefined> => {
+	const cli = resolve_cli(name_or_cli, args, options?.cwd, log, options);
+	if (!cli) return;
+	return spawn(cli.id, args, options);
+};
+
+/**
+ * Spawns a CLI if available using Belt's `spawn_process`.
+ * If a string is provided for `name_or_cli`, it checks first local to the cwd and then globally.
+ * @returns `undefined` if no CLI is found, or the spawn result
+ */
+export const spawn_cli_process = (
+	name_or_cli: string | Cli,
+	args: string[] = [],
+	log?: Logger,
+	options?: SpawnOptions | undefined,
+): Spawned_Process | undefined => {
+	const cli = resolve_cli(name_or_cli, args, options?.cwd, log, options);
+	if (!cli) return;
+	return spawn_process(cli.id, args, options);
+};
+
+export const resolve_cli = (
+	name_or_cli: string | Cli,
+	args: string[] = [],
+	cwd: string | URL | undefined,
+	log?: Logger,
+	options?: SpawnOptions | undefined,
+): Cli | undefined => {
+	let final_cli;
+	if (typeof name_or_cli === 'string') {
+		const found = find_cli(name_or_cli, cwd, options);
+		if (!found) return;
+		final_cli = found;
+	} else {
+		final_cli = name_or_cli;
+	}
+	if (log) {
+		log.info(print_command_args([final_cli.name].concat(args)));
+	}
+	return final_cli;
+};
+
+export const to_cli_name = (cli: string | Cli): string =>
+	typeof cli === 'string' ? cli : cli.name;

package/src/lib/commit.task.ts

@@ -0,0 +1,33 @@
+import {spawn} from '@ryanatkn/belt/process.js';
+import {z} from 'zod';
+
+import type {Task} from './task.js';
+import {Git_Origin, git_current_branch_name, git_push} from './git.js';
+
+export const Args = z
+	.object({
+		_: z
+			.array(z.string(), {
+				description: 'the git commit message, the same as git commit -m or --message',
+			})
+			.default([]),
+		origin: Git_Origin.describe('git origin to commit to').default('origin'),
+	})
+	.strict();
+export type Args = z.infer<typeof Args>;
+
+export const task: Task<Args> = {
+	summary: 'commit and push to a new branch',
+	Args,
+	run: async ({args}): Promise<void> => {
+		const {
+			_: [message],
+			origin,
+		} = args;
+
+		const branch = await git_current_branch_name();
+
+		await spawn('git', ['commit', '-a', '-m', message]);
+		await git_push(origin, branch, undefined, true);
+	},
+};

package/src/lib/config.test.ts

@@ -0,0 +1,71 @@
+import {test} from 'uvu';
+import * as assert from 'uvu/assert';
+
+import {DEFAULT_SEARCH_EXCLUDER, load_config} from './config.js';
+
+test('load_config', async () => {
+	const config = await load_config();
+	assert.ok(config);
+});
+
+test('DEFAULT_SEARCH_EXCLUDER', () => {
+	const assert_includes = (path: string, exclude: boolean) => {
+		const m = `should ${exclude ? 'exclude' : 'include '}: ${path}`;
+		const b = (v: boolean) => (exclude ? !v : v);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`a/${path}/c`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`a/${path}/c/d.js`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`a/${path}/c/d.e.js`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`a/${path}/`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`a/${path}`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`/a/${path}/c`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`/a/${path}/c/d.js`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`/a/${path}/c/d.e.js`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`/a/${path}/`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`/a/${path}`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`/${path}/a`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`/${path}/a/b.js`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`/${path}/a/b.e.js`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`/${path}/`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`/${path}`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`./${path}/a`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`./${path}/a/b.js`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`./${path}/a/b.c.js`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`./${path}/`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`./${path}`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`${path}/a`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`${path}/a/b.js`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`${path}/a/b.c.js`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(`${path}/`)), m);
+		assert.ok(b(DEFAULT_SEARCH_EXCLUDER.test(path)), m);
+	};
+
+	assert_includes('node_modules', false);
+	assert_includes('dist', false);
+	assert_includes('build', false);
+	assert_includes('.git', false);
+	assert_includes('.gro', false);
+	assert_includes('.svelte-kit', false);
+
+	assert_includes('a', true);
+	assert_includes('nodemodules', true);
+
+	// Special exception for `gro/dist/`, but not `gro/build/` etc because they're not usecases.
+	assert_includes('gro/build', false);
+	assert_includes('gro/buildE', true);
+	assert_includes('groE/build', false);
+	assert_includes('gro/dist', true);
+	assert_includes('node_modules/gro/dist', true);
+	assert_includes('node_modules/@someuser/gro/dist', true);
+	assert_includes('node_modules/@someuser/foo/gro/dist', false);
+	assert_includes('gro/distE', true);
+	assert_includes('groE/dist', false);
+	assert_includes('Egro/dist', false);
+	assert_includes('Ebuild', true);
+	assert_includes('buildE', true);
+	assert_includes('grobuild', true);
+	assert_includes('distE', true);
+	assert_includes('Edist', true);
+	assert_includes('grodist', true);
+});
+
+test.run();