bunigniter 0.2.0

package/dist/cli/templates.ts

@@ -0,0 +1,283 @@
+/**
+ * Shared template renderer for all `make:*` CLI commands.
+ * Single source of truth — update here to affect all generators.
+ */
+export function render(template: string, data: Record<string, any>): string {
+	return template.replace(/\{\{(\w+)\}\}/g, (_, key: string) => String(data[key] ?? ''))
+}
+
+/** Route controller template. */
+export function controller(name: string, prefix: string): string {
+	return render(`/**
+ * {{Name}} controller
+ *
+ * GET  {{prefix}}/{{name}}
+ * POST {{prefix}}/{{name}}
+ * PUT  {{prefix}}/{{name}}/:id
+ * DELETE {{prefix}}/{{name}}/:id
+ */
+import { Controller } from 'bunigniter'
+
+export class {{Name}} extends Controller {
+	async index() {
+		return this.json({ message: '{{name}} index' })
+	}
+
+	async show(id: number) {
+		return this.json({ message: '{{name}} show', id })
+	}
+
+	async create() {
+		const v = this.validate(this.body, {
+			// name: 'required'
+		})
+		if (v.fails()) return this.badRequest(v.errors)
+		return this.json({ message: '{{name}} created' }, 201)
+	}
+
+	async update(id: number) {
+		return this.json({ message: '{{name}} updated', id })
+	}
+
+	async destroy(id: number) {
+		return this.json({ message: '{{name}} deleted', id })
+	}
+}
+`, { name, Name: name.charAt(0).toUpperCase() + name.slice(1), prefix })
+}
+
+/** DB schema template. */
+export function model(name: string, columns: string): string {
+	const tableName = name.toLowerCase() + 's'
+	const cols = columns.split(',').filter(Boolean).map((c: string) => {
+		const [colName, colType] = c.trim().split(':')
+		return { name: colName || 'id', type: colType || 'string' }
+	})
+	const fieldDefs = cols.map((c: any) => {
+		if (c.type === 'number' || c.type === 'integer') {
+			return `  ${c.name}: integer('${c.name}'),`
+		}
+		return `  ${c.name}: text('${c.name}'),`
+	}).join('\n')
+
+	return `import { sqliteTable, integer, text } from 'drizzle-orm/sqlite-core'
+
+export const ${tableName} = sqliteTable('${tableName}', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+${fieldDefs}
+  createdAt: text('created_at').default('CURRENT_TIMESTAMP'),
+})
+`
+}
+
+/** Migration file template. */
+export function migration(name: string): string {
+	const timestamp = Date.now()
+	const tableName = name.toLowerCase().replace(/^create_|^add_|^drop_/, '').replace(/_table$/, '') + 's'
+	const isCreate = name.toLowerCase().startsWith('create')
+
+	return `-- Migration: ${name}
+-- Generated at: ${new Date().toISOString()}
+
+${isCreate ? `CREATE TABLE IF NOT EXISTS ${tableName} (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now'))
+);` : `-- Add your migration SQL here
+-- ALTER TABLE ${tableName} ADD COLUMN ...;`}
+`
+}
+
+/** Middleware template. */
+export function middleware(name: string): string {
+	return render(`/**
+ * {{name}} middleware
+ */
+import { defineMiddleware } from 'bunigniter'
+
+export default defineMiddleware(async (c, next) => {
+  const start = performance.now()
+  await next()
+  const duration = Math.round((performance.now() - start) * 100) / 100
+  c.set.headers ??= {}
+  c.set.headers['X-{{Name}}-Time'] = \`\${duration}ms\`
+})
+`, { name, Name: name.charAt(0).toUpperCase() + name.slice(1) })
+}
+
+/** CLI command template. */
+export function command(name: string): string {
+	return render(`/**
+ * {{name}} command — scaffolded CLI command
+ */
+import type { CommandArgs } from '../cli/types'
+
+export default {
+  name: '{{name}}',
+  desc: 'Description for {{name}}',
+  async run(args: CommandArgs) {
+    console.log('Running {{name}} with args:', args)
+  }
+}
+`, { name })
+}
+
+/** Test file template. */
+export function test(name: string): string {
+	return render(`/**
+ * {{name}} tests
+ */
+import { describe, it, expect } from 'vitest'
+
+describe('{{Name}}', () => {
+  it('should work', () => {
+    expect(1 + 1).toBe(2)
+  })
+})
+`, { name, Name: name.charAt(0).toUpperCase() + name.slice(1) })
+}
+
+/** Queue job template. */
+export function job(name: string): string {
+	return render(`/**
+ * {{name}} job — queue worker
+ */
+import type { Job } from 'bunigniter/helpers/queue'
+
+export default async function (job: Job) {
+  const { data } = job
+  console.log('Processing {{name}} job:', data)
+  // Add your job logic here
+}
+`, { name })
+}
+
+/** Mail class template. */
+export function mail(name: string): string {
+	return render(`/**
+ * {{name}} mail
+ */
+export async function send{{Name}}(to: string, data: Record<string, any> = {}) {
+  // const { mail } = await import('bunigniter/helpers/mail')
+  // await mail.send({ to, subject: '{{Name}}', html: \`<h1>\${data.title}</h1>\` })
+  console.log('Sending {{name}} mail to', to, data)
+}
+`, { name, Name: name.charAt(0).toUpperCase() + name.slice(1) })
+}
+
+/** Seeder template. */
+export function seeder(name: string): string {
+	return render(`/**
+ * {{name}} seeder
+ */
+export default async function seed(ctx: any) {
+  const { db } = ctx
+  // await db.query('INSERT INTO {{name}} (name) VALUES (?)', ['Sample'])
+  console.log('Seeding {{name}}...')
+}
+`, { name })
+}
+
+/** Event template. */
+export function eventTemplate(name: string): string {
+	return render(`/**
+ * {{name}} event
+ */
+export class {{Name}} {
+  constructor(public readonly data: any) {}
+}
+`, { name, Name: name.charAt(0).toUpperCase() + name.slice(1) })
+}
+
+/** Listener template. */
+export function listener(name: string): string {
+	return render(`/**
+ * {{name}} listener
+ */
+export default async function handle{{Name}}(event: any) {
+  console.log('Handling {{name}}:', event.data)
+}
+`, { name, Name: name.charAt(0).toUpperCase() + name.slice(1) })
+}
+
+/** Service provider template. */
+export function provider(name: string): string {
+	return render(`/**
+ * {{name}} service provider
+ */
+export default {
+  register() {
+    // Register bindings here
+  },
+  boot() {
+    // Run after all providers are registered
+  },
+}
+`, { name })
+}
+
+/** Policy template. */
+export function policy(name: string): string {
+	return render(`/**
+ * {{name}} policy
+ */
+export class {{Name}}Policy {
+  view(user: any, resource: any) { return true }
+  create(user: any) { return true }
+  update(user: any, resource: any) { return user.id === resource.user_id }
+  delete(user: any, resource: any) { return user.id === resource.user_id }
+}
+`, { name, Name: name.charAt(0).toUpperCase() + name.slice(1) })
+}
+
+/** Form request template. */
+export function formRequest(name: string): string {
+	return render(`/**
+ * {{name}} form request
+ */
+import { z } from 'zod'
+
+export const {{Name}}Schema = z.object({
+  // name: z.string().min(2),
+  // email: z.string().email(),
+})
+
+export type {{Name}}Data = z.infer<typeof {{Name}}Schema>
+`, { name, Name: name.charAt(0).toUpperCase() + name.slice(1) })
+}
+
+/** API resource template. */
+export function resource(name: string): string {
+	return render(`/**
+ * {{name}} API resource
+ */
+export interface {{Name}} {
+  id: number
+  // Add fields here
+  createdAt: string
+  updatedAt: string
+}
+
+export function {{name}}ToJson(item: {{Name}}): Record<string, any> {
+  return {
+    id: item.id,
+    // Map fields here
+    createdAt: item.createdAt,
+  }
+}
+`, { name, Name: name.charAt(0).toUpperCase() + name.slice(1) })
+}
+
+/** Validation rule template. */
+export function rule(name: string): string {
+	return render(`/**
+ * {{name}} validation rule
+ */
+export function {{name}}(value: any, params?: string): string | null {
+  if (!value) return null
+  // Add validation logic
+  // return 'Validation failed'
+  return null
+}
+`, { name })
+}

package/dist/client/index.ts

@@ -0,0 +1,159 @@
+/**
+ * Typed Fetch Client — Void-style type-safe API client.
+ *
+ * Generates a type-safe fetch client from route definitions.
+ * In the browser, uses `fetch`. In the server, calls `app.fetch()` directly.
+ *
+ * @example
+ * ```ts
+ * import { api } from 'nexusts/client'
+ *
+ * // GET: fully typed response
+ * const users = await api.get('/api/users')
+ *
+ * // POST: typed body + response
+ * const created = await api.post('/api/users', { name: 'Alice', email: 'a@b.com' })
+ *
+ * // With params
+ * const user = await api.get('/api/users/:id', { params: { id: '42' } })
+ *
+ * // With query
+ * const result = await api.get('/api/search', { query: { q: 'hello' } })
+ * ```
+ */
+
+export interface FetchOptions {
+	/** HTTP method. Default: GET */
+	method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH'
+
+	/** Request body (auto-serialized to JSON). */
+	body?: any
+
+	/** Query parameters. */
+	query?: Record<string, string | number | boolean | undefined>
+
+	/** URL path parameters (e.g. `{ id: '42' }` for /:id). */
+	params?: Record<string, string | number>
+
+	/** Additional headers. */
+	headers?: Record<string, string>
+
+	/** Base URL. Default: '' (same origin). */
+	baseURL?: string
+
+	/** Abort signal. */
+	signal?: AbortSignal
+
+	/** Timeout in ms. */
+	timeout?: number
+}
+
+export interface FetchError {
+	status: number
+	data: any
+	response: Response
+}
+
+/**
+ * Typed fetch helper.
+ *
+ * @param path - URL path (supports `:param` placeholders)
+ * @param options - Request options
+ * @returns Parsed response body
+ *
+ * @example
+ * ```ts
+ * import { fetch } from 'nexusts/client'
+ * const users = await fetch('/api/users')
+ * ```
+ */
+export async function fetch<T = any>(path: string, options: FetchOptions = {}): Promise<T> {
+	const { method = 'GET', body, query, params, headers: extraHeaders, baseURL = '', signal, timeout } = options
+
+	// Interpolate path params
+	let resolvedPath = path
+	if (params) {
+		for (const [key, value] of Object.entries(params)) {
+			resolvedPath = resolvedPath.replace(`:${key}`, String(value))
+		}
+	}
+
+	// Build URL
+	const url = new URL(resolvedPath, baseURL || 'http://localhost')
+	if (query) {
+		for (const [key, value] of Object.entries(query)) {
+			if (value !== undefined && value !== '') {
+				url.searchParams.set(key, String(value))
+			}
+		}
+	}
+
+	// Build request
+	const headers: Record<string, string> = {
+		...(extraHeaders ?? {}),
+	}
+	if (body && method !== 'GET') {
+		headers['content-type'] = 'application/json'
+	}
+
+	const requestInit: RequestInit = {
+		method,
+		headers,
+		signal,
+		...(body && method !== 'GET' ? { body: JSON.stringify(body) } : {}),
+	}
+
+	// Timeout handling
+	let timeoutId: Timer | undefined
+	if (timeout) {
+		const controller = new AbortController()
+		timeoutId = setTimeout(() => controller.abort(), timeout)
+		requestInit.signal = controller.signal
+	}
+
+	try {
+		const response = await fetch(url.toString().replace(/^http:\/\/localhost/, ''), requestInit)
+
+		if (!response.ok) {
+			const error: FetchError = {
+				status: response.status,
+				data: await response.json().catch(() => null),
+				response,
+			}
+			throw error
+		}
+
+		// Handle empty responses
+		const contentType = response.headers.get('content-type') ?? ''
+		if (contentType.includes('application/json')) {
+			return response.json()
+		}
+		if (contentType.includes('text/')) {
+			return response.text() as unknown as T
+		}
+		return undefined as unknown as T
+	} finally {
+		if (timeoutId) clearTimeout(timeoutId)
+	}
+}
+
+/**
+ * Convenience methods matching Void's fetch pattern.
+ */
+export const api = {
+	get<T = any>(path: string, options?: Omit<FetchOptions, 'method'>): Promise<T> {
+		return fetch<T>(path, { ...options, method: 'GET' })
+	},
+	post<T = any>(path: string, body?: any, options?: Omit<FetchOptions, 'method' | 'body'>): Promise<T> {
+		return fetch<T>(path, { ...options, method: 'POST', body })
+	},
+	put<T = any>(path: string, body?: any, options?: Omit<FetchOptions, 'method' | 'body'>): Promise<T> {
+		return fetch<T>(path, { ...options, method: 'PUT', body })
+	},
+	delete<T = any>(path: string, options?: Omit<FetchOptions, 'method'>): Promise<T> {
+		return fetch<T>(path, { ...options, method: 'DELETE' })
+	},
+	patch<T = any>(path: string, body?: any, options?: Omit<FetchOptions, 'method' | 'body'>): Promise<T> {
+		return fetch<T>(path, { ...options, method: 'PATCH', body })
+	},
+}