bunigniter 0.2.0

package/dist/db/validators.ts

@@ -0,0 +1,229 @@
+/**
+ * Schema-Derived Validators — Void-style createInsertSchema / createSelectSchema / createUpdateSchema.
+ *
+ * Generates Zod schemas from Drizzle table definitions for use with
+ * `defineHandler.withValidator()`.
+ *
+ * @example
+ * ```ts
+ * // db/schema.ts
+ * import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core'
+ * import { createInsertSchema } from 'nexusts/db'
+ *
+ * export const users = sqliteTable('users', {
+ *   id: integer('id').primaryKey({ autoIncrement: true }),
+ *   name: text('name').notNull(),
+ *   email: text('email').notNull().unique(),
+ *   role: text('role').notNull().default('user'),
+ * })
+ *
+ * export const insertUserSchema = createInsertSchema(users, {
+ *   name: (schema) => schema.min(2),
+ *   email: (schema) => schema.email(),
+ * })
+ * ```
+ *
+ * Then in a route handler:
+ * ```ts
+ * import { defineHandler } from 'nexusts'
+ * import { insertUserSchema } from '@schema'
+ *
+ * export const POST = defineHandler.withValidator({
+ *   body: insertUserSchema,
+ * })(async (c, { body }) => {
+ *   return db.insert(users).values(body).returning()
+ * })
+ * ```
+ */
+import { z } from 'zod'
+
+/**
+ * Column type info extracted from a Drizzle table column definition.
+ */
+interface ColumnInfo {
+	name: string
+	type: string
+	notNull: boolean
+	hasDefault: boolean
+	isPrimaryKey: boolean
+	isAutoIncrement: boolean
+}
+
+/**
+ * Infer column info from a Drizzle table's `_` internal structure.
+ * This works with drizzle-orm >= 0.45.
+ */
+function getColumns(table: any): ColumnInfo[] {
+	const cols: ColumnInfo[] = []
+	// Drizzle stores columns in table[Symbol.for('drizzle:columns')]
+	const drizzleCols = table?.[Symbol.for('drizzle:columns')] ?? table?.['_'] ?? {}
+
+	for (const [name, col] of Object.entries<any>(drizzleCols)) {
+		cols.push({
+			name,
+			type: col?.type ?? 'text',
+			notNull: col?.notNull ?? false,
+			hasDefault: col?.hasDefault ?? false,
+			isPrimaryKey: col?.primaryKey ?? false,
+			isAutoIncrement: col?.autoIncrement ?? false,
+		})
+	}
+
+	// Fallback: try to get columns from the table's structure
+	if (cols.length === 0) {
+		for (const key of Object.keys(table)) {
+			if (key.startsWith('_') || key === 'name' || key === 'Symbol') continue
+			const col = table[key]
+			if (col && typeof col === 'object' && col.name) {
+				cols.push({
+					name: col.name,
+					type: col.type ?? 'text',
+					notNull: col.notNull ?? false,
+					hasDefault: col.hasDefault ?? false,
+					isPrimaryKey: col.primaryKey ?? false,
+					isAutoIncrement: col.autoIncrement ?? false,
+				})
+			}
+		}
+	}
+
+	return cols
+}
+
+/**
+ * Map Drizzle column types to Zod schemas.
+ */
+function columnToZod(col: ColumnInfo): z.ZodTypeAny {
+	let schema: z.ZodTypeAny
+
+	switch (col.type) {
+		case 'number':
+		case 'integer':
+		case 'serial':
+			schema = z.number()
+			break
+		case 'boolean':
+			schema = z.boolean()
+			break
+		case 'json':
+		case 'jsonb':
+			schema = z.record(z.any())
+			break
+		case 'text':
+		case 'varchar':
+		case 'char':
+		case 'string':
+		default:
+			schema = z.string()
+			break
+	}
+
+	// Apply nullability
+	if (!col.notNull) {
+		schema = schema.nullable().optional()
+	}
+	if (col.isAutoIncrement) {
+		schema = schema.optional()
+	}
+
+	return schema
+}
+
+/**
+ * Create a Zod schema for INSERT operations.
+ * Auto-generated columns (id, timestamps with defaults) become optional.
+ *
+ * @param table - Drizzle table definition
+ * @param refinements - Optional field-level refinements (e.g. `.min(2)`, `.email()`)
+ * @returns Zod object schema
+ *
+ * @example
+ * ```ts
+ * export const insertUserSchema = createInsertSchema(users, {
+ *   name: (schema) => schema.min(2),
+ *   email: (schema) => schema.email(),
+ * })
+ * ```
+ */
+export function createInsertSchema<T extends Record<string, any>>(
+	table: any,
+	refinements?: Partial<{
+		[K in keyof T]: (schema: z.ZodTypeAny) => z.ZodTypeAny
+	}>
+): z.ZodObject<any> {
+	const columns = getColumns(table)
+	const shape: Record<string, z.ZodTypeAny> = {}
+
+	for (const col of columns) {
+		// Skip auto-increment primary keys (DB generates them)
+		if (col.isAutoIncrement) continue
+
+		let schema = columnToZod(col)
+
+		// Apply refinements
+		if (refinements && refinements[col.name as keyof typeof refinements]) {
+			const refine = refinements[col.name as keyof typeof refinements]!
+			schema = refine(schema)
+		}
+
+		shape[col.name] = schema
+	}
+
+	return z.object(shape)
+}
+
+/**
+ * Create a Zod schema for SELECT operations.
+ * All columns are optional (you might not select all).
+ *
+ * @param table - Drizzle table definition
+ * @returns Zod object schema
+ *
+ * @example
+ * ```ts
+ * export const selectUserSchema = createSelectSchema(users)
+ * ```
+ */
+export function createSelectSchema(table: any): z.ZodObject<any> {
+	const columns = getColumns(table)
+	const shape: Record<string, z.ZodTypeAny> = {}
+
+	for (const col of columns) {
+		shape[col.name] = columnToZod(col).optional()
+	}
+
+	return z.object(shape)
+}
+
+/**
+ * Create a Zod schema for UPDATE operations.
+ * All fields are optional (partial update).
+ *
+ * @param table - Drizzle table definition
+ * @param refinements - Optional field-level refinements
+ * @returns Zod object schema
+ *
+ * @example
+ * ```ts
+ * export const updateUserSchema = createUpdateSchema(users, {
+ *   email: (schema) => schema.email(),
+ * })
+ * ```
+ */
+export function createUpdateSchema<T extends Record<string, any>>(
+	table: any,
+	refinements?: Partial<{
+		[K in keyof T]: (schema: z.ZodTypeAny) => z.ZodTypeAny
+	}>
+): z.ZodObject<any> {
+	const insertSchema = createInsertSchema(table, refinements)
+	const shape = insertSchema.shape
+
+	// Make all fields optional
+	const optionalShape: Record<string, z.ZodTypeAny> = {}
+	for (const [key, schema] of Object.entries(shape)) {
+		optionalShape[key] = (schema as z.ZodTypeAny).optional()
+	}
+
+	return z.object(optionalShape)
+}

package/dist/edge-builder.ts

@@ -0,0 +1,120 @@
+/**
+ * Edge routes builder — generates pre-compiled route handlers for Edge runtimes.
+ *
+ * Usage: `bun run bi build:edge`
+ *
+ * This scans `pages/` and generates `edge-app.ts` — a static file with
+ * all routes pre-registered. Works on Cloudflare Workers, Deno, etc.
+ */
+import { readdirSync, statSync, writeFileSync, existsSync, readFileSync } from 'node:fs'
+import { join, basename } from 'node:path'
+
+const CWD = process.cwd()
+
+export async function buildEdgeRoutes(): Promise<void> {
+	// Scan routes/ for controllers (was pages/, now routes/)
+	const routesDir = join(CWD, 'routes')
+	if (!existsSync(routesDir)) {
+		console.error('[build] No routes/ directory found.')
+		return
+	}
+
+	const files = scanDir(routesDir)
+	const imports: string[] = []
+	const routes: string[] = []
+
+	for (const file of files) {
+		if (file.endsWith('.server.ts')) continue
+
+		const fullPath = join(routesDir, file)
+		const s = statSync(fullPath)
+		if (!s.isFile()) continue
+
+		// Read the file to find the exported class name
+		const content = readFileSync(fullPath, 'utf-8')
+		const classMatch = content.match(/export class (\w+) extends Controller/)
+		const name = classMatch ? classMatch[1] : 'UnknownController'
+		const importPath = `./routes/${file}`
+		const isIndex = basename(file, '.ts') === 'index'
+		const prefix = process.env.ROUTER_PREFIX ?? '/api'
+
+		// Build URL path
+		let urlPath
+		if (isIndex) {
+			urlPath = prefix
+		} else {
+			urlPath = file
+				.replace(/\.ts$/, '')
+				.replace(/\.\.\./g, '*')
+				.replace(/\[(\w+)\]/g, ':$1')
+			urlPath = `${prefix}/${urlPath}`
+		}
+
+		imports.push(`import { ${name} } from '${importPath}'`)
+
+		const methodMap: Record<string, string> = {
+			index: 'GET', show: 'GET', create: 'POST',
+			update: 'PUT', destroy: 'DELETE',
+		}
+		const idMethods = new Set(['show', 'update', 'destroy'])
+
+		// Only generate routes for methods that exist on the controller
+		for (const [method, verb] of Object.entries(methodMap)) {
+			if (!content.includes(`async ${method}`)) continue
+
+			const isIdMethod = idMethods.has(method)
+			const methodPath = isIdMethod ? `${urlPath}/:id` : urlPath
+			const httpMethod = verb.toLowerCase()
+
+			routes.push(`  app.${httpMethod}('${methodPath}', async (ctx) => {
+    const ctrl = new ${name}()
+    ;(ctrl as any).ctx = ctx
+    const id = ctx.params?.id ? Number(ctx.params.id) : undefined
+    const result = await ctrl.${method}(${isIdMethod ? 'id' : ''})
+    if (result instanceof Response) return result
+    return new Response(JSON.stringify(result ?? {}), {
+      headers: { 'content-type': 'application/json' }
+    })
+  })`)
+		}
+	}
+
+	const output = `// Auto-generated edge routes — do not edit manually.
+// Generated by: bun run bi build:edge
+
+import { Elysia } from 'elysia'
+
+${imports.join('\n')}
+
+const app = new Elysia()
+
+// Health check
+app.get('/health', () => new Response(JSON.stringify({
+  status: 'ok',
+  runtime: typeof Bun !== 'undefined' ? 'bun' : 'edge',
+}), { headers: { 'content-type': 'application/json' }}))
+
+// Routes
+${routes.join('\n\n')}
+
+export default app
+`
+
+	const outPath = join(CWD, 'edge-app.ts')
+	writeFileSync(outPath, output, 'utf-8')
+	console.log(`[build] Edge routes written to ${outPath}`)
+	console.log(`[build] ${files.length} controllers, ${routes.length} routes`)
+}
+
+function scanDir(dir: string, baseDir = ''): string[] {
+	const files: string[] = []
+	const entries = readdirSync(dir, { withFileTypes: true })
+	for (const entry of entries) {
+		if (entry.isDirectory()) {
+			files.push(...scanDir(join(dir, entry.name), baseDir ? `${baseDir}/${entry.name}` : entry.name))
+		} else if (entry.isFile() && entry.name.endsWith('.ts') && !entry.name.startsWith('_')) {
+			files.push(baseDir ? `${baseDir}/${entry.name}` : entry.name)
+		}
+	}
+	return files.sort()
+}

package/dist/edge.ts

@@ -0,0 +1,69 @@
+/**
+ * Edge entry point — for Cloudflare Workers, Deno, and other Edge runtimes.
+ *
+ * Unlike the Bun entry point (`src/index.ts`), this version:
+ * - Does NOT use file-based routing (pages are pre-registered)
+ * - Does NOT use node:fs modules
+ * - Uses Elysia v2's web-standard adapter
+ * - Exposes `fetch` handler directly
+ *
+ * Usage (Cloudflare Workers):
+ * ```ts
+ * import app from './src/edge'
+ * export default { fetch: app.fetch }
+ * ```
+ *
+ * Usage (Deno):
+ * ```ts
+ * import app from './src/edge'
+ * Deno.serve(app.fetch)
+ * ```
+ */
+import { Elysia } from 'elysia'
+import { applyMiddleware } from './helpers/middleware'
+
+/**
+ * Create an edge-compatible application.
+ * Routes must be registered manually or via a pre-built router.
+ */
+export function createEdgeApp(config?: { middleware?: any }) {
+	const app = new Elysia()
+
+	// Apply middleware
+	applyMiddleware(app, config?.middleware)
+
+	// Health check
+	app.get('/health', () => new Response(JSON.stringify({
+		status: 'ok',
+		runtime: typeof Bun !== 'undefined' ? 'bun' :
+			typeof (globalThis as any).Deno !== 'undefined' ? 'deno' :
+			typeof (globalThis as any).navigator !== 'undefined' ? 'cloudflare' :
+			'unknown',
+		timestamp: new Date().toISOString(),
+	}), {
+		headers: { 'content-type': 'application/json' },
+	}))
+
+	return app
+}
+
+/**
+ * Register a route directly (edge-compatible, no filesystem access).
+ *
+ * @example
+ * ```ts
+ * import { createEdgeApp, register } from './src/edge'
+ * const app = createEdgeApp()
+ * register(app, 'GET', '/api/hello', () => new Response('Hello Edge!'))
+ * export default { fetch: app.fetch }
+ * ```
+ */
+export function register(
+	app: Elysia,
+	method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH',
+	path: string,
+	handler: (...args: any[]) => any
+): void {
+	const lower = method.toLowerCase() as 'get' | 'post' | 'put' | 'delete' | 'patch'
+	;(app as any)[lower](path, handler)
+}

package/dist/helpers/cache.ts

@@ -0,0 +1,173 @@
+/**
+ * Cache — CodeIgniter-style key-value cache with TTL support.
+ *
+ * @example
+ * ```ts
+ * // In a controller
+ * const users = this.cache.get('users_list')
+ * if (!users) {
+ *   const data = await this.db.query('SELECT * FROM users')
+ *   this.cache.set('users_list', data, 300) // 5 min TTL
+ * }
+ * ```
+ */
+export interface CacheOptions {
+	/** Default TTL in seconds. Default: 60 */
+	defaultTtl?: number
+
+	/** Max cache entries. Default: 1000 */
+	maxEntries?: number
+}
+
+interface CacheEntry {
+	data: any
+	expiresAt: number
+}
+
+/** In-memory cache store. */
+const store = new Map<string, CacheEntry>()
+
+/** Periodic cleanup. */
+let cleanupTimer: Timer | null = null
+function ensureCleanup(interval = 30000) {
+	if (cleanupTimer) return
+	cleanupTimer = setInterval(() => {
+		const now = Date.now()
+		for (const [key, entry] of store) {
+			if (entry.expiresAt <= now) store.delete(key)
+		}
+	}, interval)
+}
+
+/**
+ * Cache service — get/set/delete/remember with TTL.
+ *
+ * Usage in a Controller (injected by the framework):
+ * ```ts
+ * this.cache.get('key')
+ * this.cache.set('key', value, 300)
+ * ```
+ */
+export class Cache {
+	private defaultTtl: number
+	private maxEntries: number
+
+	constructor(options: CacheOptions = {}) {
+		this.defaultTtl = options.defaultTtl ?? 60
+		this.maxEntries = options.maxEntries ?? 1000
+		ensureCleanup()
+	}
+
+	/**
+	 * Get a cached value.
+	 * Returns undefined if key doesn't exist or is expired.
+	 */
+	get<T = any>(key: string): T | undefined {
+		const entry = store.get(key)
+		if (!entry) return undefined
+		if (entry.expiresAt <= Date.now()) {
+			store.delete(key)
+			return undefined
+		}
+		return entry.data as T
+	}
+
+	/**
+	 * Set a cached value with optional TTL.
+	 *
+	 * @param key - Cache key
+	 * @param value - Value to store
+	 * @param ttl - Time to live in seconds. Default: config.defaultTtl
+	 */
+	set(key: string, value: any, ttl?: number): void {
+		if (store.size >= this.maxEntries) {
+			// Evict oldest entry
+			const oldest = store.entries().next().value
+			if (oldest) store.delete(oldest[0])
+		}
+
+		store.set(key, {
+			data: value,
+			expiresAt: Date.now() + (ttl ?? this.defaultTtl) * 1000,
+		})
+	}
+
+	/**
+	 * Delete a cached value.
+	 */
+	delete(key: string): void {
+		store.delete(key)
+	}
+
+	/**
+	 * Clear all cached values.
+	 */
+	clear(): void {
+		store.clear()
+	}
+
+	/**
+	 * Check if a key exists and is not expired.
+	 */
+	has(key: string): boolean {
+		const entry = store.get(key)
+		if (!entry) return false
+		if (entry.expiresAt <= Date.now()) {
+			store.delete(key)
+			return false
+		}
+		return true
+	}
+
+	/**
+	 * Remember — get or set via a callback.
+	 *
+	 * @example
+	 * ```ts
+	 * const users = await this.cache.remember('users', 300, async () => {
+	 *   return this.db.query('SELECT * FROM users')
+	 * })
+	 * ```
+	 */
+	async remember<T>(key: string, ttl: number, callback: () => Promise<T>): Promise<T> {
+		const cached = this.get<T>(key)
+		if (cached !== undefined) return cached
+
+		const value = await callback()
+		this.set(key, value, ttl)
+		return value
+	}
+
+	/**
+	 * Increment a numeric value.
+	 */
+	increment(key: string, amount = 1): number {
+		const current = this.get<number>(key) ?? 0
+		const newValue = current + amount
+		this.set(key, newValue)
+		return newValue
+	}
+
+	/**
+	 * Decrement a numeric value.
+	 */
+	decrement(key: string, amount = 1): number {
+		return this.increment(key, -amount)
+	}
+
+	/** Number of cached entries. */
+	get size(): number {
+		return store.size
+	}
+}
+
+/**
+ * Create a shared cache instance.
+ */
+let _instance: Cache | null = null
+export function createCache(options?: CacheOptions): Cache {
+	if (!_instance) {
+		_instance = new Cache(options)
+	}
+	return _instance
+}

package/dist/helpers/cors.ts

@@ -0,0 +1,103 @@
+/**
+ * CORS middleware — Cross-Origin Resource Sharing.
+ *
+ * @example
+ * ```ts
+ * // config/app.ts
+ * export default {
+ *   middleware: {
+ *     cors: {
+ *       origin: ['https://myapp.com', 'http://localhost:5173'],
+ *       methods: ['GET', 'POST', 'PUT', 'DELETE'],
+ *     }
+ *   }
+ * }
+ * ```
+ */
+import { Elysia } from 'elysia'
+
+export interface CORSOptions {
+	/** Allowed origins. Default: '*' */
+	origin?: string | string[] | ((origin: string) => boolean | string | undefined)
+
+	/** Allowed methods. Default: 'GET,POST,PUT,PATCH,DELETE,OPTIONS' */
+	methods?: string
+
+	/** Allowed headers. Default: 'Content-Type,Authorization,X-Inertia' */
+	allowedHeaders?: string
+
+	/** Expose headers. */
+	exposeHeaders?: string
+
+	/** Allow credentials (cookies). Default: true */
+	credentials?: boolean
+
+	/** Max age for preflight cache (seconds). Default: 86400 */
+	maxAge?: number
+}
+
+/**
+ * Create a CORS middleware plugin.
+ */
+export function corsMiddleware(options: CORSOptions = {}) {
+	const {
+		origin = '*',
+		methods = 'GET,POST,PUT,PATCH,DELETE,OPTIONS',
+		allowedHeaders = 'Content-Type,Authorization,X-Inertia,X-Requested-With',
+		credentials = true,
+		maxAge = 86400,
+		exposeHeaders,
+	} = options
+
+	const app = new Elysia({ name: 'nexus-cors' })
+
+	app.derive(async (ctx: any) => {
+		const requestOrigin = ctx.request.headers.get('origin')
+
+		// Determine allowed origin
+		let allowOrigin = '*'
+		if (origin === '*') {
+			allowOrigin = requestOrigin ?? '*'
+		} else if (typeof origin === 'string') {
+			allowOrigin = origin
+		} else if (Array.isArray(origin)) {
+			if (requestOrigin && origin.includes(requestOrigin)) {
+				allowOrigin = requestOrigin
+			}
+		} else if (typeof origin === 'function') {
+			const result = origin(requestOrigin ?? '')
+			if (result) allowOrigin = typeof result === 'string' ? result : requestOrigin ?? '*'
+		}
+
+		// Handle preflight
+		if (ctx.request.method === 'OPTIONS') {
+			return new Response(null, {
+				status: 204,
+				headers: {
+					'Access-Control-Allow-Origin': allowOrigin,
+					'Access-Control-Allow-Methods': methods,
+					'Access-Control-Allow-Headers': allowedHeaders,
+					'Access-Control-Max-Age': String(maxAge),
+					...(credentials ? { 'Access-Control-Allow-Credentials': 'true' } : {}),
+				},
+			})
+		}
+
+		// Store for later use
+		return { _corsOrigin: allowOrigin }
+	})
+
+	app.afterResponse((ctx: any) => {
+		const allowOrigin = ctx._corsOrigin ?? '*' 
+		ctx.set.headers ??= {}
+		ctx.set.headers['Access-Control-Allow-Origin'] = allowOrigin
+		if (credentials && allowOrigin !== '*') {
+			ctx.set.headers['Access-Control-Allow-Credentials'] = 'true'
+		}
+		if (exposeHeaders) {
+			ctx.set.headers['Access-Control-Expose-Headers'] = exposeHeaders
+		}
+	})
+
+	return app
+}