Use Rolldown for builds

.github/workflows/release-feature-branch.yaml

@@ -23,6 +23,9 @@ jobs:
         with: { run_install: false }
       - uses: actions/setup-node@v6
         with: { node-version: '24', registry-url: 'https://registry.npmjs.org', cache: 'pnpm', cache-dependency-path: pnpm-lock.yaml }
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: 1.3.1
       - run: pnpm install --frozen-lockfile --prefer-offline
       - name: Compute version suffix
         id: meta

.github/workflows/release-latest.yaml

@@ -126,6 +126,11 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-pnpm-store-
 
+      - uses: oven-sh/setup-bun@v2
+        name: Install Bun
+        with:
+          bun-version: 1.3.1
+
       - name: Install dependencies
         run: pnpm install
 

.gitignore

@@ -14,6 +14,7 @@ rollup.config-*.mjs
 drizzle-seed/src/dev
 drizzle-orm/tmp
 drizzle-orm/types-bench.ts
+drizzle-orm/src/version.temp.ts
 typeperf-test/tmp.tsconfig.json
 typeperf-test/trace
 typeperf-test/lib/big-schema.ts

build/index.ts

@@ -0,0 +1,94 @@
+import { $, Glob } from 'bun';
+import { rm } from 'fs/promises';
+import { availableParallelism, FixedThreadPool } from 'poolifier-web-worker';
+
+export type WorkerIn = {
+	name: string;
+	content: string;
+	extension: string;
+}[];
+
+export type WorkerOut = {
+	name: string;
+	code: string;
+}[];
+
+export async function build(config: {
+	readme: string;
+	skip?: {
+		distDelete?: boolean;
+		resolveTsPaths?: boolean;
+	};
+	customPackageJsonExports?: Record<string, any>;
+}) {
+	if (!config.skip?.distDelete) await rm('dist', { recursive: true, force: true });
+	await $`rolldown --config rolldown.config.ts`;
+	if (!config.skip?.resolveTsPaths) await $`resolve-tspaths`;
+
+	await Promise.all([
+		Bun.write('dist/README.md', Bun.file(config.readme)),
+		Bun.write('dist/package.json', Bun.file('package.json')),
+	]);
+	if (config.customPackageJsonExports) {
+		const pkg = await Bun.file('dist/package.json').json();
+		pkg.exports = config.customPackageJsonExports;
+		await Bun.write('dist/package.json', JSON.stringify(pkg, null, 2));
+	}
+
+	const declarationFilesGlob = new Glob('**/*.d.ts');
+	for await (const file of declarationFilesGlob.scan('./dist')) {
+		const ctsFileName = file.replace(/\.d\.ts$/, '.d.cts');
+		await Bun.write(`dist/${ctsFileName}`, Bun.file(`dist/${file}`));
+	}
+
+	const [cjsFiles, jsFiles, mjsFiles] = await Promise.all([
+		getFilesFromGlob('**/*.{cjs,d.cts}'),
+		getFilesFromGlob('**/*.{js,d.ts}'),
+		getFilesFromGlob('**/*.{mjs,d.mts}'),
+	]);
+	const parallelism = availableParallelism();
+	const allFiles = splitArray([
+		...cjsFiles.map(({ content, name }) => ({ content, name, extension: '.cjs' })),
+		...jsFiles.map(({ content, name }) => ({ content, name, extension: '.js' })),
+		...mjsFiles.map(({ content, name }) => ({ content, name, extension: '.mjs' })),
+	], parallelism);
+
+	const pool = new FixedThreadPool<WorkerIn, WorkerOut>(
+		parallelism,
+		new URL('./worker.ts', import.meta.url),
+		{
+			errorEventHandler: (err) => {
+				console.error('Worker error:', err);
+				process.exit(1);
+			},
+		},
+	);
+	const writeFiles = await pool.mapExecute(allFiles);
+	await pool.destroy();
+	await Promise.all(writeFiles.flat(1).map(async ({ code, name }) => await Bun.write(name, code)));
+}
+
+async function getFilesFromGlob(pattern: string) {
+	const files = await Array.fromAsync(new Glob(pattern).scan('./dist'));
+	return await Promise.all(files.map(async (file) => ({
+		content: await Bun.file(`dist/${file}`).text(),
+		name: `dist/${file}`,
+	})));
+}
+
+function splitArray<T>(array: T[], parts: number): T[][] {
+	const result: T[][] = [];
+	const len = array.length;
+	const baseSize = Math.floor(len / parts);
+	const remainder = len % parts;
+
+	let start = 0;
+	for (let i = 0; i < parts; i++) {
+		const extra = i < remainder ? 1 : 0;
+		const end = start + baseSize + extra;
+		result.push(array.slice(start, end));
+		start = end;
+	}
+
+	return result;
+}

build/worker.ts

@@ -0,0 +1,99 @@
+import MagicString from 'magic-string';
+import path from 'node:path';
+import { parseSync, Visitor } from 'oxc-parser';
+import { ThreadWorker } from 'poolifier-web-worker';
+import type { WorkerIn, WorkerOut } from '.';
+
+export default new ThreadWorker<WorkerIn, WorkerOut>(async (data) => {
+	if (!data) return [];
+	const files: WorkerOut = [];
+
+	for (const { content, name, extension } of data) {
+		const code = parseSync(name, content);
+		const magic = new MagicString(content);
+
+		const visitor = new Visitor({
+			ImportDeclaration(node) {
+				magic.overwrite(
+					node.source.start + 1,
+					node.source.end - 1,
+					fixImportPath(magic.slice(node.source.start + 1, node.source.end - 1), name, extension),
+				);
+			},
+			//   visitExportAllDeclaration(path) {
+			//     path.value.source.value = fixImportPath(path.value.source.value, name, extension);
+			//     this.traverse(path);
+			//   },
+			//   visitExportNamedDeclaration(path) {
+			//     if (path.value.source) {
+			//       path.value.source.value = fixImportPath(path.value.source.value, name, extension);
+			//     }
+			//     this.traverse(path);
+			//   },
+			CallExpression(node) {
+				if (node.callee.type === 'Identifier' && node.callee.name === 'require' && (node.arguments[0] as any)?.value) {
+					magic.overwrite(
+						node.arguments[0]!.start + 1,
+						node.arguments[0]!.end - 1,
+						fixImportPath(magic.slice(node.arguments[0]!.start + 1, node.arguments[0]!.end - 1), name, extension),
+					);
+				}
+			},
+			//   visitTSImportType(path) {
+			//     path.value.argument.value = resolvePathAlias(path.value.argument.value, name);
+			//     this.traverse(path);
+			//   },
+			AwaitExpression(node) {
+				const nodeStr = magic.slice(node.start, node.end);
+				if (nodeStr.startsWith(`await import(`)) {
+					const fullImportPath = magic.slice(node.start, node.end);
+					let importPath = magic.slice(node.start + 'await import('.length + 1, node.end - 2);
+
+					if (nodeStr.includes('./')) {
+						importPath = fixImportPath(
+							importPath,
+							name,
+							extension,
+						);
+					}
+
+					const statement = fullImportPath.includes('await import(') && extension === '.cjs'
+						? 'require('
+						: 'await import(';
+					magic.overwrite(
+						node.start,
+						node.end,
+						`${statement}"${importPath}")`,
+					);
+				}
+			},
+		});
+
+		visitor.visit(code.program);
+		files.push({
+			code: magic.toString(),
+			name,
+		});
+	}
+
+	return files;
+});
+
+function resolvePathAlias(importPath: string, file: string) {
+	if (importPath.startsWith('~/')) {
+		const relativePath = path.relative(path.dirname(file), path.resolve('dist', importPath.slice(2)));
+		importPath = relativePath.startsWith('.') ? relativePath : './' + relativePath;
+	}
+
+	return importPath;
+}
+
+function fixImportPath(importPath: string, file: string, ext: string) {
+	importPath = resolvePathAlias(importPath, file);
+
+	if (!/\..*\.(js|ts|cjs|cts|mjs|mts)$/.test(importPath)) {
+		return importPath;
+	}
+
+	return importPath.replace(/\.(js|ts|cjs|cts|mjs|mts)$/, ext);
+}

drizzle-arktype/package.json

@@ -4,32 +4,30 @@
 	"description": "Generate arktype schemas from Drizzle ORM schemas",
 	"type": "module",
 	"scripts": {
-		"build": "tsx scripts/build.ts",
+		"build": "bun scripts/build.ts",
 		"build:artifact": "pnpm run build",
 		"b": "pnpm build",
 		"test:types": "cd tests && tsc",
 		"pack": "(cd dist && npm pack --pack-destination ..) && rm -f package.tgz && mv *.tgz package.tgz",
 		"pack:artifact": "pnpm run pack",
 		"publish": "npm publish package.tgz",
 		"test": "vitest run",
-		"bench:types": "tsx ./benchmarks/types.ts"
+		"bench:types": "bun ./benchmarks/types.ts"
 	},
 	"exports": {
 		".": {
 			"import": {
-				"types": "./index.d.mts",
-				"default": "./index.mjs"
+				"types": "./index.d.ts",
+				"default": "./index.js"
 			},
 			"require": {
-				"types": "./index.d.cjs",
+				"types": "./index.d.cts",
 				"default": "./index.cjs"
-			},
-			"types": "./index.d.ts",
-			"default": "./index.mjs"
+			}
 		}
 	},
 	"main": "./index.cjs",
-	"module": "./index.mjs",
+	"module": "./index.js",
 	"types": "./index.d.ts",
 	"publishConfig": {
 		"provenance": true
@@ -63,15 +61,9 @@
 	},
 	"devDependencies": {
 		"@ark/attest": "^0.45.8",
-		"@rollup/plugin-typescript": "^11.1.0",
 		"@types/node": "^18.15.10",
 		"arktype": "^2.1.10",
-		"cpy": "^10.1.0",
 		"drizzle-orm": "link:../drizzle-orm/dist",
-		"json-rules-engine": "7.3.1",
-		"rimraf": "^5.0.0",
-		"rollup": "^3.29.5",
-		"tsx": "^4.19.3",
-		"zx": "^7.2.2"
+		"json-rules-engine": "7.3.1"
 	}
 }

drizzle-arktype/rolldown.config.ts

@@ -0,0 +1,41 @@
+import { defineConfig, type RolldownOptions } from 'rolldown';
+import { dts } from 'rolldown-plugin-dts';
+
+const common: RolldownOptions = {
+	input: 'src/index.ts',
+	external: [
+		/^drizzle-orm\/?/,
+		'arktype',
+	],
+	tsconfig: 'tsconfig.build.json',
+};
+
+export default defineConfig([
+	{
+		...common,
+		output: [
+			{
+				format: 'esm',
+				dir: 'dist',
+				entryFileNames: '[name].js',
+				chunkFileNames: '[name]-[hash].js',
+				sourcemap: true,
+			},
+		],
+		plugins: [dts({
+			tsconfig: 'tsconfig.build.json',
+		})],
+	},
+	{
+		...common,
+		output: [
+			{
+				format: 'cjs',
+				dir: 'dist',
+				entryFileNames: '[name].cjs',
+				chunkFileNames: '[name]-[hash].cjs',
+				sourcemap: true,
+			},
+		],
+	},
+]);

drizzle-arktype/scripts/build.ts

@@ -1,16 +1,5 @@
-#!/usr/bin/env -S pnpm tsx
-import 'zx/globals';
-import cpy from 'cpy';
+import { build } from '~build';
 
-await fs.remove('dist');
-await $`rollup --config rollup.config.ts --configPlugin typescript`;
-await $`resolve-tspaths`;
-await fs.copy('README.md', 'dist/README.md');
-await cpy('dist/**/*.d.ts', 'dist', {
-	rename: (basename) => basename.replace(/\.d\.ts$/, '.d.mts'),
+await build({
+	readme: 'README.md',
 });
-await cpy('dist/**/*.d.ts', 'dist', {
-	rename: (basename) => basename.replace(/\.d\.ts$/, '.d.cts'),
-});
-await fs.copy('package.json', 'dist/package.json');
-await $`scripts/fix-imports.ts`;