chore(ci): add "publish" GHA

.github/workflows/publish.yml

@@ -0,0 +1,51 @@
+name: Publish to codemod registry
+
+on:
+  push:
+    branches: ["main"]
+    paths: ["recipes/**"]
+  pull_request:
+    branches: ["main"]
+    paths: ["recipes/**"]
+    types: [closed]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: dorny/paths-filter@v3
+        id: filter
+        name: Filter codemods
+        with:
+          list-files: shell
+          filters: |
+            codemods:
+              - '**/.codemodrc.json'
+
+      - name: Collate updates
+        run: |
+          echo "Modified files: ${{steps.filter.outputs.codemods_files}}"
+          echo "Modified status: ${{steps.filter.outputs.codemods}}"
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version-file: '.nvmrc'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci --include="optional"
+
+      - name: Generate bundle & publish to codemod registry
+        run: >-
+          node
+          --no-warnings
+          --experimental-strip-types
+          ./build/publish.mts
+          --recipes=${{steps.filter.outputs.codemods_files}}
+          --status=${{steps.filter.outputs.codemods}}

build/bundle.mts

@@ -0,0 +1,44 @@
+import path from 'node:path';
+
+import { build, type BuildOptions } from 'esbuild';
+
+
+export const outfile = 'bundle.js';
+
+export async function bundle(recipeAbsPath: string) {
+	const pjson = await import(path.join(recipeAbsPath, 'package.json'), jsonImportAttrs)
+		.then(pluckDefault);
+	const recipeOptions = await import(path.join(recipeAbsPath, 'esbuild.config.ts'))
+		.then(pluckDefault)
+		.catch(handleImportErr);
+	const options: BuildOptions = {
+		...recipeOptions,
+		bundle: true,
+		entryPoints: [pjson.main],
+		loader: {
+			// '.node': 'file',
+		},
+		minify: true,
+		outfile: 'bundle.js',
+		outdir: recipeAbsPath,
+		platform: 'node',
+		sourcemap: 'inline',
+		target: 'node20',
+	};
+
+	console.debug(`Generating bundle for ${pjson.name} with options`);
+	console.debug(options);
+
+	await build(options);
+
+	console.log(`Bundle for ${pjson.name} generated successfully`);
+}
+
+function pluckDefault(mod) {
+	return mod.default;
+}
+function handleImportErr(err: NodeJS.ErrnoException) {
+	if (err.code !== 'ERR_MODULE_NOT_FOUND') throw err;
+	return {};
+}
+const jsonImportAttrs: ImportCallOptions = { with: { type: 'json' } };

build/publish.mts

@@ -0,0 +1,41 @@
+import path from 'node:path';
+import { argv, cwd } from 'node:process';
+import { parseArgs } from 'node:util';
+
+import { publish } from 'codemod';
+
+import { bundle, outfile } from './bundle.mts';
+
+
+const {
+	recipes,
+	status,
+} = parseArgs({
+	allowPositionals: true,
+	args: argv,
+	options: {
+		recipes: { type: 'string' },
+		status: { type: 'boolean' },
+	},
+}).values;
+const recipeRelPaths: string[] = recipes?.slice(1, -1).split(' ') ?? [];
+
+if (!status) throw new Error(`Unexpected status: ${status}`);
+
+const rootPath = cwd();
+
+const n = recipeRelPaths.length;
+const publications = new Array(n);
+for (let r = n - 1; r > -1; r--) {
+	const recipeRelPath = recipeRelPaths[r];
+	const recipeAbsPath = path.join(rootPath, recipeRelPath);
+
+	publications[r] = bundle(recipeAbsPath)
+		.then(() => publish(path.join(recipeAbsPath, outfile)));
+}
+
+Promise.allSettled(publications)
+	.then(
+		() => console.log('Publishing complete'),
+		() => console.error('Publishing failed'),
+	);

build/publish.spec.mts

@@ -0,0 +1,63 @@
+import assert from 'node:assert/strict';
+import { cwd, argv } from 'node:process';
+import {
+	before,
+	describe,
+	it,
+	mock,
+} from 'node:test';
+
+
+type Mock = ReturnType<typeof mock.fn>['mock'];
+
+describe('Publishing', () => {
+	const CWD = cwd();
+	const outfile = 'out.js';
+	let mock__bundle: Mock;
+	let mock__publish: Mock;
+	let mock__consoleErr: Mock;
+	let mock__consoleLog: Mock;
+
+	before(async () => {
+		const bundle = mock.fn();
+		mock__bundle = bundle.mock;
+		const publish = mock.fn();
+		mock__publish = publish.mock;
+
+		mock.module('codemod', {
+			namedExports: {
+				publish,
+			},
+		});
+		mock.module('./bundle.mts', {
+			namedExports: {
+				bundle,
+				outfile,
+			},
+		});
+		// mock.method(console, 'error');
+		// mock.method(console, 'log');
+	});
+
+	it('should', async () => {
+		mock__bundle.mockImplementation(async () => { });
+		mock__publish.mockImplementation(() => { });
+
+		argv[2] = '--recipes=("a" "b")';
+		argv[3] = '--status';
+
+		await import('./publish.mts');
+
+		assert.deepEqual(mock__bundle.calls, [
+			{ arguments: [`${CWD}/a`] },
+			{ arguments: [`${CWD}/b`] },
+		]);
+
+		assert.deepEqual(mock__publish.calls, [
+			{ arguments: [`${CWD}/a`] },
+			{ arguments: [`${CWD}/b`] },
+		]);
+
+		assert.match(mock__consoleLog.calls[0].arguments[0], /Publishing complete/);
+	});
+});