@buzola/codegen 0.0.1

package/src/__tests__/codegen.test.ts

@@ -0,0 +1,229 @@
+import { describe, expect, it } from 'bun:test'
+import { generateRouteModule } from '../generator/codegen.js'
+
+describe('generateRouteModule', () => {
+	it('emits BuzolaPersistentParams when persistentParams is provided', () => {
+		const output = generateRouteModule({
+			tree: [],
+			routesDir: '/tmp/routes',
+			outputPath: '/tmp/buzola.gen.ts',
+			persistentParams: ['lang'],
+		})
+
+		expect(output).toContain('interface BuzolaPersistentParams')
+		expect(output).toContain('lang: true;')
+	})
+
+	it('quotes hyphenated persistentParams keys', () => {
+		const output = generateRouteModule({
+			tree: [],
+			routesDir: '/tmp/routes',
+			outputPath: '/tmp/buzola.gen.ts',
+			persistentParams: ['create-new-project', 'source', 'utm-medium'],
+		})
+
+		expect(output).toContain("'create-new-project': true;")
+		expect(output).toContain('source: true;')
+		expect(output).toContain("'utm-medium': true;")
+	})
+
+	it('quotes hyphenated page param keys in BuzolaPageMap', () => {
+		const output = generateRouteModule({
+			tree: [{
+				segment: 'users',
+				fullPath: '/users',
+				filePath: '/tmp/routes/users.tsx',
+				exportName: 'default',
+				isLayout: false,
+				isIndex: false,
+				isNotFound: false,
+				isPathlessGroup: false,
+				pageExports: [{
+					pageId: 'users',
+					exportName: 'default',
+					routePattern: '/users',
+					params: [
+						{ name: 'create-new-project', optional: true, array: false },
+						{ name: 'source', optional: false, array: false },
+					],
+				}],
+				children: [],
+			}],
+			routesDir: '/tmp/routes',
+			outputPath: '/tmp/buzola.gen.ts',
+		})
+
+		expect(output).toContain("'create-new-project'?: string")
+		expect(output).toContain('source: string')
+	})
+
+	it('does not emit BuzolaPersistentParams without persistentParams', () => {
+		const output = generateRouteModule({
+			tree: [],
+			routesDir: '/tmp/routes',
+			outputPath: '/tmp/buzola.gen.ts',
+		})
+
+		expect(output).not.toContain('BuzolaPersistentParams')
+	})
+
+	it('emits BuzolaPageMap interface', () => {
+		const output = generateRouteModule({
+			tree: [],
+			routesDir: '/tmp/routes',
+			outputPath: '/tmp/buzola.gen.ts',
+		})
+
+		expect(output).toContain('interface BuzolaPageMap')
+	})
+
+	it('emits pageRegistry export', () => {
+		const output = generateRouteModule({
+			tree: [],
+			routesDir: '/tmp/routes',
+			outputPath: '/tmp/buzola.gen.ts',
+		})
+
+		expect(output).toContain('export const pageRegistry')
+	})
+
+	it('generates correct lazy import for default export', () => {
+		const output = generateRouteModule({
+			tree: [{
+				segment: 'users',
+				fullPath: '/users',
+				filePath: '/tmp/routes/users.tsx',
+				exportName: 'default',
+				isLayout: false,
+				isIndex: false,
+				isNotFound: false,
+				isPathlessGroup: false,
+				pageExports: [{ pageId: 'users', exportName: 'default', routePattern: '/users', params: [] }],
+				children: [],
+			}],
+			routesDir: '/tmp/routes',
+			outputPath: '/tmp/buzola.gen.ts',
+		})
+
+		expect(output).toContain('.then(m => ({ default: m.default.component }))')
+	})
+
+	it('generates correct lazy import for named export', () => {
+		const output = generateRouteModule({
+			tree: [{
+				segment: 'users',
+				fullPath: '/users',
+				isLayout: false,
+				isIndex: false,
+				isNotFound: false,
+				isPathlessGroup: false,
+				children: [{
+					segment: 'detail',
+					fullPath: '/users/detail',
+					filePath: '/tmp/routes/users.tsx',
+					exportName: 'detail',
+					isLayout: false,
+					isIndex: false,
+					isNotFound: false,
+					isPathlessGroup: false,
+					pageExports: [{ pageId: 'users/detail', exportName: 'detail', routePattern: '/users/detail', params: [] }],
+					children: [],
+				}],
+			}],
+			routesDir: '/tmp/routes',
+			outputPath: '/tmp/buzola.gen.ts',
+		})
+
+		expect(output).toContain('.then(m => ({ default: m.detail.component }))')
+		expect(output).toContain("'users/detail': '/users/detail'")
+	})
+
+	it('generates matchPath when routePattern differs from file position', () => {
+		const output = generateRouteModule({
+			tree: [{
+				segment: 'login',
+				fullPath: '/login',
+				filePath: '/tmp/routes/login/_layout.tsx',
+				isLayout: true,
+				isIndex: false,
+				isNotFound: false,
+				isPathlessGroup: false,
+				children: [{
+					segment: '',
+					fullPath: '/login',
+					filePath: '/tmp/routes/login/index.tsx',
+					exportName: 'default',
+					isLayout: false,
+					isIndex: true,
+					isNotFound: false,
+					isPathlessGroup: false,
+					pageExports: [{ pageId: 'login', exportName: 'default', routePattern: '/', params: [] }],
+					children: [],
+				}],
+			}],
+			routesDir: '/tmp/routes',
+			outputPath: '/tmp/buzola.gen.ts',
+		})
+
+		expect(output).toContain("matchPath: '/'")
+		expect(output).toContain('isIndex: true')
+	})
+
+	it('does not generate matchPath when routePattern matches file position', () => {
+		const output = generateRouteModule({
+			tree: [{
+				segment: 'users',
+				fullPath: '/users',
+				filePath: '/tmp/routes/users.tsx',
+				exportName: 'default',
+				isLayout: false,
+				isIndex: false,
+				isNotFound: false,
+				isPathlessGroup: false,
+				pageExports: [{ pageId: 'users', exportName: 'default', routePattern: '/users', params: [] }],
+				children: [],
+			}],
+			routesDir: '/tmp/routes',
+			outputPath: '/tmp/buzola.gen.ts',
+		})
+
+		expect(output).not.toContain('matchPath')
+	})
+
+	it('generates separate imports for default and named exports from same file', () => {
+		const output = generateRouteModule({
+			tree: [{
+				segment: 'users',
+				fullPath: '/users',
+				filePath: '/tmp/routes/users.tsx',
+				exportName: 'default',
+				isLayout: false,
+				isIndex: false,
+				isNotFound: false,
+				isPathlessGroup: false,
+				pageExports: [{ pageId: 'users', exportName: 'default', routePattern: '/users', params: [] }],
+				children: [{
+					segment: 'detail',
+					fullPath: '/users/detail',
+					filePath: '/tmp/routes/users.tsx',
+					exportName: 'detail',
+					isLayout: false,
+					isIndex: false,
+					isNotFound: false,
+					isPathlessGroup: false,
+					pageExports: [{ pageId: 'users/detail', exportName: 'detail', routePattern: '/users/detail', params: [] }],
+					children: [],
+				}],
+			}],
+			routesDir: '/tmp/routes',
+			outputPath: '/tmp/buzola.gen.ts',
+		})
+
+		// Two separate import lines for the same file
+		expect(output).toContain('m.default.component')
+		expect(output).toContain('m.detail.component')
+		// Both in page registry
+		expect(output).toContain("'users': '/users'")
+		expect(output).toContain("'users/detail': '/users/detail'")
+	})
+})

package/src/__tests__/conventions.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'bun:test'
+import { isRouteFile, parseDirName, parseFileName, parseRouteFile } from '../conventions.js'
+
+describe('isRouteFile', () => {
+	it('accepts .tsx files', () => {
+		expect(isRouteFile('index.tsx')).toBe(true)
+	})
+
+	it('accepts .jsx files', () => {
+		expect(isRouteFile('_layout.jsx')).toBe(true)
+	})
+
+	it('rejects .css files', () => {
+		expect(isRouteFile('style.css')).toBe(false)
+	})
+})
+
+describe('parseFileName', () => {
+	it('parses layout files', () => {
+		const result = parseFileName('_layout')
+		expect(result.isLayout).toBe(true)
+		expect(result.segment).toBe('')
+	})
+
+	it('parses not-found files', () => {
+		const result = parseFileName('_404')
+		expect(result.isNotFound).toBe(true)
+		expect(result.segment).toBe('')
+	})
+
+	it('parses index files', () => {
+		const result = parseFileName('index')
+		expect(result.isIndex).toBe(true)
+		expect(result.segment).toBe('')
+	})
+
+	it('parses regular page files', () => {
+		const result = parseFileName('about')
+		expect(result.segment).toBe('about')
+		expect(result.isLayout).toBe(false)
+		expect(result.isIndex).toBe(false)
+		expect(result.isNotFound).toBe(false)
+	})
+
+	it('treats bracket names as plain file names', () => {
+		const result = parseFileName('[userId]')
+		expect(result.segment).toBe('[userId]')
+		expect(result.isLayout).toBe(false)
+		expect(result.isIndex).toBe(false)
+		expect(result.isNotFound).toBe(false)
+	})
+})
+
+describe('parseDirName', () => {
+	it('parses pathless groups', () => {
+		const result = parseDirName('(auth)')
+		expect(result.isPathlessGroup).toBe(true)
+		expect(result.segment).toBe('')
+	})
+
+	it('parses regular directories', () => {
+		const result = parseDirName('users')
+		expect(result.segment).toBe('users')
+		expect(result.isPathlessGroup).toBe(false)
+	})
+
+	it('treats bracket names as plain directory names', () => {
+		const result = parseDirName('[userId]')
+		expect(result.segment).toBe('[userId]')
+		expect(result.isPathlessGroup).toBe(false)
+	})
+})
+
+describe('parseRouteFile', () => {
+	it('parses root index', () => {
+		const result = parseRouteFile('index.tsx')
+		expect(result.isIndex).toBe(true)
+		expect(result.segment).toBe('')
+	})
+
+	it('parses nested layout', () => {
+		const result = parseRouteFile('users/_layout.tsx')
+		expect(result.isLayout).toBe(true)
+		expect(result.segment).toBe('users')
+	})
+
+	it('parses regular nested file', () => {
+		const result = parseRouteFile('users/detail.tsx')
+		expect(result.segment).toBe('users/detail')
+		expect(result.isLayout).toBe(false)
+		expect(result.isIndex).toBe(false)
+	})
+})

package/src/__tests__/page-extractor.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, it } from 'bun:test'
+import { extractPages } from '../generator/page-extractor.js'
+
+describe('extractPages', () => {
+	it('extracts default page export', async () => {
+		const mockModule = {
+			default: {
+				__buzolaPage: true,
+				component: () => null,
+				route: '/users/:userId',
+				paramsMeta: [
+					{ name: 'userId', optional: false, array: false },
+					{ name: 'tab', optional: true, array: false },
+				],
+			},
+		}
+
+		const pages = await extractPages('/fake/path.tsx', async () => mockModule as Record<string, unknown>)
+
+		expect(pages).toHaveLength(1)
+		expect(pages[0].exportName).toBe('default')
+		expect(pages[0].isDefault).toBe(true)
+		expect(pages[0].route).toBe('/users/:userId')
+		expect(pages[0].params).toEqual([
+			{ name: 'userId', optional: false, array: false },
+			{ name: 'tab', optional: true, array: false },
+		])
+	})
+
+	it('extracts named page exports', async () => {
+		const mockModule = {
+			detail: {
+				__buzolaPage: true,
+				component: () => null,
+				route: '/project/:id',
+				paramsMeta: [{ name: 'id', optional: false, array: false }],
+			},
+			list: {
+				__buzolaPage: true,
+				component: () => null,
+				route: '/projects',
+				paramsMeta: [],
+			},
+		}
+
+		const pages = await extractPages('/fake/path.tsx', async () => mockModule as Record<string, unknown>)
+
+		expect(pages).toHaveLength(2)
+		expect(pages[0].exportName).toBe('detail')
+		expect(pages[0].isDefault).toBe(false)
+		expect(pages[1].exportName).toBe('list')
+	})
+
+	it('skips non-page exports', async () => {
+		const mockModule = {
+			default: {
+				__buzolaPage: true,
+				component: () => null,
+				route: '/about',
+				paramsMeta: [],
+			},
+			helperFunction: () => 'not a page',
+			SOME_CONSTANT: 42,
+		}
+
+		const pages = await extractPages('/fake/path.tsx', async () => mockModule as Record<string, unknown>)
+
+		expect(pages).toHaveLength(1)
+		expect(pages[0].exportName).toBe('default')
+	})
+
+	it('returns empty for module without pages', async () => {
+		const mockModule = {
+			default: () => null,
+		}
+
+		const pages = await extractPages('/fake/path.tsx', async () => mockModule as Record<string, unknown>)
+		expect(pages).toEqual([])
+	})
+
+	it('handles page without route', async () => {
+		const mockModule = {
+			default: {
+				__buzolaPage: true,
+				component: () => null,
+				paramsMeta: [],
+			},
+		}
+
+		const pages = await extractPages('/fake/path.tsx', async () => mockModule as Record<string, unknown>)
+
+		expect(pages).toHaveLength(1)
+		expect(pages[0].route).toBeUndefined()
+	})
+})

package/src/__tests__/resolve.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from 'bun:test'
+import * as fs from 'node:fs'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import { buildVirtualSource, resolveOptions, resolveVirtualModuleId } from '../resolve.js'
+
+function makeTempDir(): string {
+	return fs.mkdtempSync(path.join(os.tmpdir(), 'buzola-resolve-test-'))
+}
+
+describe('resolveVirtualModuleId', () => {
+	it('returns defaults when name is undefined', () => {
+		expect(resolveVirtualModuleId(undefined)).toEqual({
+			pluginName: 'buzola',
+			id: 'virtual:buzola/routes',
+		})
+	})
+
+	it('includes name in plugin name and virtual module ID', () => {
+		expect(resolveVirtualModuleId('admin')).toEqual({
+			pluginName: 'buzola:admin',
+			id: 'virtual:buzola/admin/routes',
+		})
+	})
+})
+
+describe('buildVirtualSource', () => {
+	it('strips trailing .ts and re-exports routes + pageRegistry', () => {
+		const source = buildVirtualSource('/abs/path/buzola.gen.ts')
+		expect(source).toContain('export { routes, pageRegistry } from')
+		expect(source).toContain('"/abs/path/buzola.gen"')
+		expect(source).not.toContain('.gen.ts"')
+	})
+
+	it('escapes the import path via JSON.stringify', () => {
+		const source = buildVirtualSource('/path "with" quotes/buzola.gen.ts')
+		const match = source.match(/from (.+?);\n$/)
+		expect(match).not.toBeNull()
+		expect(JSON.parse(match![1])).toBe('/path "with" quotes/buzola.gen')
+	})
+})
+
+describe('resolveOptions', () => {
+	it('uses built-in defaults when input is empty', async () => {
+		const root = makeTempDir()
+		try {
+			const result = await resolveOptions({ root })
+			expect(result.root).toBe(root)
+			expect(result.routesDir).toBe(path.join(root, 'src/routes'))
+			expect(result.outputPath).toBe(path.join(root, 'src/buzola.gen.ts'))
+			expect(result.persistentParams).toBeUndefined()
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true })
+		}
+	})
+
+	it('input values override defaults', async () => {
+		const root = makeTempDir()
+		try {
+			const result = await resolveOptions({
+				root,
+				routesDir: 'app/routes',
+				output: 'gen/routes.gen.ts',
+				persistentParams: ['lang'],
+			})
+			expect(result.routesDir).toBe(path.join(root, 'app/routes'))
+			expect(result.outputPath).toBe(path.join(root, 'gen/routes.gen.ts'))
+			expect(result.persistentParams).toEqual(['lang'])
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true })
+		}
+	})
+
+	it('reads buzola.config.ts when input field is absent', async () => {
+		const root = makeTempDir()
+		try {
+			fs.writeFileSync(
+				path.join(root, 'buzola.config.ts'),
+				`export default {
+					routesDir: 'configured/routes',
+					output: 'configured/out.gen.ts',
+					persistentParams: ['theme'],
+				}`,
+			)
+			const result = await resolveOptions({ root })
+			expect(result.routesDir).toBe(path.join(root, 'configured/routes'))
+			expect(result.outputPath).toBe(path.join(root, 'configured/out.gen.ts'))
+			expect(result.persistentParams).toEqual(['theme'])
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true })
+		}
+	})
+
+	it('input overrides config file per-field', async () => {
+		const root = makeTempDir()
+		try {
+			fs.writeFileSync(
+				path.join(root, 'buzola.config.ts'),
+				`export default { routesDir: 'configured', output: 'configured.gen.ts' }`,
+			)
+			const result = await resolveOptions({ root, routesDir: 'override' })
+			expect(result.routesDir).toBe(path.join(root, 'override'))
+			expect(result.outputPath).toBe(path.join(root, 'configured.gen.ts'))
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true })
+		}
+	})
+
+	it('returns absolute paths', async () => {
+		const root = makeTempDir()
+		try {
+			const result = await resolveOptions({ root, routesDir: './nested/routes' })
+			expect(path.isAbsolute(result.routesDir)).toBe(true)
+			expect(path.isAbsolute(result.outputPath)).toBe(true)
+			expect(path.isAbsolute(result.root)).toBe(true)
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true })
+		}
+	})
+})