weifuwu 0.25.2 → 0.27.0

package/middleware/validate.ts

@@ -0,0 +1,186 @@
+import type { ZodSchema } from 'zod'
+import type { Middleware } from '../types.ts'
+
+// Augment Context with parsed property (shared with upload)
+declare module '../types.ts' {
+  interface Context {
+    parsed: Record<string, unknown>
+  }
+}
+
+/** Validation middleware — a {@link Middleware} that injects `ctx.parsed` with validated data. */
+export type ValidateModule = Middleware
+
+export interface ValidationSchemas {
+  body?: ZodSchema
+  query?: ZodSchema
+  params?: ZodSchema
+  headers?: ZodSchema
+}
+
+/**
+ * Parse application/x-www-form-urlencoded body string into Record<string, string>.
+ * Duplicate keys become comma-joined string (most common HTML form behavior).
+ */
+function parseFormBody(text: string): Record<string, string> {
+  const params = new URLSearchParams(text)
+  const result: Record<string, string> = {}
+  for (const [key, value] of params) {
+    // Collapse duplicates: last value wins (matches standard server behavior)
+    result[key] = value
+  }
+  return result
+}
+
+// Parse body text based on content-type. Returns parsed value or raw string.
+// Rules:
+// - application/x-www-form-urlencoded => Record<string, string> via URLSearchParams
+// - application/json, text/*, vendor+json, or any non-form/non-multipart => try JSON.parse
+// - multipart/form-data => raw string (handled by upload())
+// - fallback => raw string
+function parseBody(text: string, ct: string): unknown {
+  if (ct.includes('application/x-www-form-urlencoded')) {
+    return parseFormBody(text)
+  }
+
+  // Try JSON parse when:
+  // - Content-Type explicitly indicates JSON (application/json, *+json)
+  // - Content-Type is text/*
+  // - Content-Type is not multipart and not urlencoded (catch-all for API types)
+  const isExplicitJson =
+    ct.includes('application/json') ||
+    ct.includes('+json') ||
+    ct.includes('text/') ||
+    ct.includes('*/json')
+  const isNotSpecialMultipart =
+    !ct.includes('multipart/form-data') && !ct.includes('application/x-www-form-urlencoded')
+
+  if (isExplicitJson || isNotSpecialMultipart) {
+    try {
+      return JSON.parse(text)
+    } catch {
+      // keep raw string
+    }
+  }
+
+  return text
+}
+
+/**
+ * Request validation middleware using Zod schemas.
+ *
+ * Validates `params`, `query`, `body`, and/or `headers` against schemas.
+ * Returns 422 with error details on mismatch.
+ * Injects `ctx.parsed` with validated-and-transformed values.
+ *
+ * ```ts
+ * import { z } from 'zod'
+ *
+ * app.get('/users/:id', validate({
+ *   params: z.object({ id: z.string() }),
+ *   query: z.object({ include: z.string().optional() }),
+ * }), handler)
+ * ```
+ */
+export function validate(schemas?: ValidationSchemas): Middleware {
+  const mw: Middleware = async (req, ctx, next) => {
+    const parsed: Record<string, unknown> = {}
+    const issues: { path: string[]; message: string }[] = []
+
+    if (schemas?.params) {
+      const result = schemas.params.safeParse(ctx.params)
+      if (result.success) {
+        parsed.params = result.data
+      } else {
+        issues.push(
+          ...result.error.issues.map((i) => ({
+            path: ['params', ...i.path.map(String)],
+            message: i.message,
+          })),
+        )
+      }
+    }
+
+    if (schemas?.query) {
+      const result = schemas.query.safeParse(ctx.query)
+      if (result.success) {
+        parsed.query = result.data
+      } else {
+        issues.push(
+          ...result.error.issues.map((i) => ({
+            path: ['query', ...i.path.map(String)],
+            message: i.message,
+          })),
+        )
+      }
+    }
+
+    if (schemas?.headers) {
+      const rawHeaders: Record<string, string> = {}
+      req.headers.forEach((v, k) => {
+        rawHeaders[k] = v
+      })
+      const result = schemas.headers.safeParse(rawHeaders)
+      if (result.success) {
+        parsed.headers = result.data
+      } else {
+        issues.push(
+          ...result.error.issues.map((i) => ({
+            path: ['headers', ...i.path.map(String)],
+            message: i.message,
+          })),
+        )
+      }
+    }
+
+    // Always attempt body parsing for non-GET/HEAD methods
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+      const ct = req.headers.get('content-type') ?? ''
+      const isForm = ct.includes('application/x-www-form-urlencoded')
+
+      // Parse body if: schema asks for it, OR it's a form (no schema needed)
+      if (schemas?.body || isForm) {
+        if (req.body === null) {
+          if (schemas?.body) {
+            issues.push({ path: ['body'], message: 'Request body is required' })
+          }
+        } else {
+          const bodyText = await req.text()
+          if (!bodyText) {
+            if (schemas?.body) {
+              issues.push({ path: ['body'], message: 'Request body is required' })
+            }
+          } else {
+            const bodyValue = parseBody(bodyText, ct)
+            if (schemas?.body) {
+              const result = schemas.body.safeParse(bodyValue)
+              if (result.success) {
+                parsed.body = result.data
+              } else {
+                issues.push(
+                  ...result.error.issues.map((i) => ({
+                    path: ['body', ...i.path.map(String)],
+                    message: i.message,
+                  })),
+                )
+              }
+            } else {
+              // No schema: still populate ctx.parsed.body with parsed value
+              // (for form-urlencoded, this is a Record<string, string>)
+              parsed.body = bodyValue as Record<string, string>
+            }
+          }
+        }
+      }
+    }
+
+    if (issues.length > 0) {
+      return Response.json({ error: 'Validation failed', issues }, { status: 400 })
+    }
+
+    ctx.parsed = { ...ctx.parsed, ...parsed }
+    return next(req, ctx)
+  }
+  mw.__meta = { injects: ['parsed'], depends: [] }
+  return mw
+}

package/package.json

@@ -1,63 +1,47 @@
 {
   "name": "weifuwu",
   "type": "module",
-  "version": "0.25.2",
-  "description": "Web-standard HTTP framework for Node.js — (req, ctx) => Response",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "version": "0.27.0",
+  "description": "Web-standard HTTP microframework for Node.js — (req, ctx) => Response",
   "exports": {
-    ".": "./dist/index.js",
-    "./react": "./dist/react.js"
+    ".": "./index.ts"
   },
   "bin": {
-    "weifuwu": "dist/cli.js"
+    "weifuwu": "./cli.ts"
   },
   "files": [
-    "dist/",
-    "cli.ts",
-    "cli/template/",
-    "opencode/ui/",
-    "README.md",
-    "LICENSE"
+    "*.ts",
+    "core/*.ts",
+    "middleware/*.ts",
+    "ai/*.ts",
+    "postgres/*.ts",
+    "postgres/**/*.ts",
+    "queue/*.ts",
+    "redis/*.ts"
   ],
   "scripts": {
-    "dev": "cd cli/template && NODE_ENV=development node --watch index.ts",
-    "start": "cd cli/template && NODE_ENV=production node index.ts",
-    "build": "esbuild index.ts --bundle --format=esm --platform=node --outfile=dist/index.js --packages=external --define:__WFW_BUNDLED__=true && esbuild cli.ts --bundle --format=esm --platform=node --outfile=dist/cli.js --packages=external && esbuild react.ts --bundle --format=esm --outfile=dist/react.js --external:react --external:react-dom",
-    "prepublishOnly": "npm run build && tsc --emitDeclarationOnly --outdir dist",
     "typecheck": "tsc --noEmit",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
-    "lint": "eslint --ext .ts,.tsx .",
+    "lint": "eslint --ext .ts .",
     "test": "node --test 'test/**/*.test.ts'",
     "test:coverage": "node --experimental-test-coverage --test 'test/**/*.test.ts'",
-    "test:typecheck": "npx tsc -p tsconfig.test.json --noEmit",
     "test:quick": "bash scripts/test-quick.sh",
-    "test:ci": "node --test --test-force-exit --test-timeout=60000 'test/**/*.test.ts'",
     "prepare": "husky"
   },
   "dependencies": {
     "@ai-sdk/openai": "^3.0.66",
-    "@aws-sdk/client-s3": "^3.1068.0",
-    "@aws-sdk/s3-request-presigner": "^3.1068.0",
     "@graphql-tools/schema": "^10",
-    "@tailwindcss/postcss": "^4",
     "ai": "^6",
-    "chokidar": "^5.0.0",
-    "esbuild": "^0.28.0",
     "graphql": "^16",
     "ioredis": "^5.11.0",
-    "jsonwebtoken": "^9.0.3",
     "nodemailer": "^8.0.10",
     "postgres": "^3.4.9",
-    "react": "^19",
-    "react-dom": "^19",
     "ws": "^8",
-    "yaml": "^2.9.0",
     "zod": "^4.4.3"
   },
   "lint-staged": {
-    "*.{ts,tsx}": [
+    "*.ts": [
       "prettier --write",
       "eslint --fix"
     ],
@@ -67,20 +51,14 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@types/jsonwebtoken": "^9.0.9",
     "@types/node": "^25.9.3",
     "@types/nodemailer": "^6.4.17",
-    "@types/react": "^19.2.17",
-    "@types/react-dom": "^19.2.3",
     "@types/ws": "^8.18.1",
     "eslint": "^10.5.0",
     "globals": "^17.6.0",
-    "happy-dom": "^20.10.3",
     "husky": "^9.1.7",
     "lint-staged": "^17.0.7",
-    "postcss": "^8.5.3",
     "prettier": "^3.8.4",
-    "tailwindcss": "^4.0.0",
     "typescript-eslint": "^8.61.0"
   }
 }

package/postgres/client.ts

@@ -0,0 +1,132 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import postgresFactory from 'postgres'
+import type { Context, Handler } from '../types.ts'
+import type { PostgresOptions, PostgresClient } from './types.ts'
+import { BoundTable, Table } from './schema/table.ts'
+import type { ColumnBuilder } from './schema/columns.ts'
+
+/** Migration tracking table name. Created automatically on first migrate(). */
+export const MIGRATIONS_TABLE = '_weifuwu_migrations'
+
+/** PostgreSQL error codes that are safe to retry. */
+const RETRYABLE_CODES = new Set(['40P01', '40001'])
+
+function isRetryable(err: unknown): boolean {
+  return err instanceof Error && 'code' in err && RETRYABLE_CODES.has((err as any).code)
+}
+
+export function postgres(opts?: string | PostgresOptions): PostgresClient {
+  const options: PostgresOptions = typeof opts === 'string' ? { connection: opts } : (opts ?? {})
+
+  const connection = options.connection ?? process.env.DATABASE_URL
+  if (!connection) {
+    throw new Error(
+      'postgres: DATABASE_URL is not set. Pass a connection string or set the DATABASE_URL environment variable.',
+    )
+  }
+
+  const stmtTimeout = options.statementTimeout ?? 30_000
+  // Inject statement_timeout via connection options parameter.
+  // URL-encoded: SET statement_timeout = <ms>
+  let connStr = typeof connection === 'string' ? connection : ''
+  if (stmtTimeout > 0 && typeof connection === 'string') {
+    const sep = connStr.includes('?') ? '&' : '?'
+    connStr = `${connStr}${sep}options=-c%20statement_timeout%3D${stmtTimeout}`
+  }
+
+  const sql = postgresFactory(connStr as any, {
+    max: options.max,
+    ssl: options.ssl,
+    idle_timeout: options.idle_timeout,
+    connect_timeout: options.connect_timeout,
+  }) as any
+
+  if (options.signal) {
+    options.signal.addEventListener(
+      'abort',
+      () => {
+        sql.end()
+      },
+      { once: true },
+    )
+  }
+
+  const closeTimeout = options.closeTimeout ?? 5
+
+  // ── Connection pool tracking ────────────────────────────────────
+  const _active = 0
+  const _waiting = 0
+  const poolMax = options.max ?? 10
+
+  const mw = ((req: Request, ctx: Context, next: Handler) => {
+    ctx.sql = sql
+    return next(req, ctx)
+  }) as unknown as PostgresClient
+  mw.__meta = { injects: ['sql'], depends: [] }
+
+  mw.sql = sql
+  mw.table = ((
+    tableOrSchema: string | Table<any>,
+    builders?: Record<string, ColumnBuilder<unknown>>,
+  ) => {
+    if (typeof tableOrSchema === 'string') {
+      return new BoundTable(sql, tableOrSchema, builders!)
+    }
+    return new BoundTable(sql, tableOrSchema.tableName, tableOrSchema.builders)
+  }) as any
+
+  mw.migrate = async () => {
+    await sql.unsafe(`
+      CREATE TABLE IF NOT EXISTS "${MIGRATIONS_TABLE}" (
+        name TEXT PRIMARY KEY,
+        applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `)
+  }
+
+  mw.markMigrated = async (moduleName: string) => {
+    await sql.unsafe(
+      `INSERT INTO "${MIGRATIONS_TABLE}" (name) VALUES ($1) ON CONFLICT DO NOTHING`,
+      [moduleName],
+    )
+  }
+
+  mw.isMigrated = async (moduleName: string): Promise<boolean> => {
+    const [row] = (await sql.unsafe(`SELECT 1 FROM "${MIGRATIONS_TABLE}" WHERE name = $1`, [
+      moduleName,
+    ])) as any[]
+    return !!row
+  }
+
+  // ── Transaction with retry ──────────────────────────────────────
+  mw.transaction = (async (fn: any, retryOpts?: { maxRetries?: number }) => {
+    const maxRetries = retryOpts?.maxRetries ?? 3
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        const result = await sql.begin(fn)
+        return result
+      } catch (err) {
+        if (attempt < maxRetries && isRetryable(err)) {
+          const delay = Math.min(100 * Math.pow(2, attempt - 1), 1000)
+          await new Promise((r) => setTimeout(r, delay))
+          continue
+        }
+        throw err
+      }
+    }
+    // Unreachable — last attempt throws above
+    throw new Error('transaction: max retries exceeded')
+  }) as any
+
+  mw.poolStats = () => ({
+    active: _active,
+    idle: poolMax - _active - _waiting,
+    waiting: _waiting,
+    max: poolMax,
+  })
+
+  mw.close = () => sql.end({ timeout: closeTimeout })
+
+  return mw
+}

package/postgres/index.ts

@@ -0,0 +1,4 @@
+export { postgres, MIGRATIONS_TABLE } from './client.ts'
+export { PgModule } from './module.ts'
+export type { PostgresOptions, PostgresClient, PostgresInjected } from './types.ts'
+export * from './schema/index.ts'

package/postgres/module.ts

@@ -0,0 +1,37 @@
+import type { PostgresClient } from './types.ts'
+
+import type { SqlClient, Closeable } from '../types.ts'
+import type { ColumnBuilder, BoundTable, Table } from './schema/index.ts'
+
+export class PgModule implements Closeable {
+  protected sql: SqlClient
+  protected pg: PostgresClient
+
+  constructor(pg: PostgresClient) {
+    this.pg = pg
+    this.sql = pg.sql
+  }
+
+  table<R extends Record<string, unknown>>(
+    tableOrSchema: string | Table<R>,
+    builders?: { [K in keyof R]: ColumnBuilder<R[K]> },
+  ): BoundTable<R> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return this.pg.table(tableOrSchema as any, builders as any)
+  }
+
+  async transaction<T>(
+    fn: (sql: SqlClient) => Promise<T>,
+    retryOpts?: { maxRetries?: number },
+  ): Promise<T> {
+    return await this.pg.transaction(fn, retryOpts)
+  }
+
+  async migrate(): Promise<void> {
+    // override in subclasses
+  }
+
+  async close(): Promise<void> {
+    await this.pg.close()
+  }
+}

package/postgres/schema/columns.ts

@@ -0,0 +1,186 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { SQL, sql } from './sql.ts'
+
+/** Reference to another table's column (foreign key). */
+export interface ColumnReference {
+  /** Referenced table name. */
+  table: string
+  /** Referenced column name (default: `'id'`). */
+  column: string
+  /** `ON DELETE` action (e.g. `'cascade'`, `'set null'`). */
+  onDelete?: string
+}
+
+/**
+ * Fluent column builder for DDL generation.
+ *
+ * ```ts
+ * text('name').notNull().unique()
+ * integer('user_id').references('users')
+ * timestamptz('created_at').default(sql`NOW()`)
+ * ```
+ */
+// @ts-nocheck - T is used at type level
+export class ColumnBuilder<T> {
+  /** Column name. */
+  name: string
+  /** SQL type string (e.g. `'TEXT'`, `'INTEGER'`). */
+  sqlType: string
+  /** Whether this column is PRIMARY KEY. */
+  isPrimaryKey = false
+  /** Whether this column allows NULL. */
+  isNullable = true
+  /** Whether this column has a UNIQUE constraint. */
+  isUnique = false
+  /** Whether the value is auto-generated (e.g. SERIAL, UUID defaults). */
+  isAutoGenerate = false
+  /** DEFAULT expression as a raw SQL string. */
+  defaultExpr: string | null = null
+  /** Foreign key reference, if any. */
+  ref: ColumnReference | null = null
+
+  constructor(name: string, sqlType: string) {
+    this.name = name
+    this.sqlType = sqlType
+  }
+
+  /** Mark as PRIMARY KEY (implies NOT NULL). */
+  primaryKey(): this {
+    this.isPrimaryKey = true
+    this.isNullable = false
+    return this
+  }
+
+  /** Add NOT NULL constraint. */
+  notNull(): this {
+    this.isNullable = false
+    return this
+  }
+
+  /** Allow NULL values (default). */
+  nullable(): this {
+    this.isNullable = true
+    return this
+  }
+
+  /** Set a DEFAULT value. Accepts raw SQL, string, number, or boolean. */
+  default(expr: SQL | string | number | boolean): this {
+    if (expr instanceof SQL) {
+      this.defaultExpr = expr.toSQL()
+    } else if (typeof expr === 'string') {
+      this.defaultExpr = `'${expr.replace(/'/g, "''")}'`
+    } else {
+      this.defaultExpr = String(expr)
+    }
+    return this
+  }
+
+  /** Add UNIQUE constraint. */
+  unique(): this {
+    this.isUnique = true
+    return this
+  }
+
+  /** Add FOREIGN KEY reference to another table. */
+  references(table: string, column = 'id', onDelete?: string): this {
+    this.ref = { table, column, onDelete }
+    return this
+  }
+}
+
+function col<T>(name: string, sqlType: string): ColumnBuilder<T> {
+  return new ColumnBuilder<T>(name, sqlType)
+}
+
+/** Auto-incrementing integer primary key (`SERIAL`). */
+export function serial(name: string) {
+  const c = col<number>(name, 'SERIAL')
+  c.isAutoGenerate = true
+  return c
+}
+/** UUID column. */
+export function uuid(name: string) {
+  return col<string>(name, 'UUID')
+}
+/** TEXT column. */
+export function text(name: string) {
+  return col<string>(name, 'TEXT')
+}
+/** INTEGER column. */
+export function integer(name: string) {
+  return col<number>(name, 'INTEGER')
+}
+/** BOOLEAN column (exported as `boolean`). */
+export function boolean_(name: string) {
+  return col<boolean>(name, 'BOOLEAN')
+}
+export { boolean_ as boolean }
+/** TIMESTAMPTZ column (timestamp with time zone). */
+export function timestamptz(name: string) {
+  return col<string>(name, 'TIMESTAMPTZ')
+}
+/** JSONB column (stores arbitrary JSON data). */
+export function jsonb<T = unknown>(name: string) {
+  return col<T>(name, 'JSONB')
+}
+/** TEXT[] column (PostgreSQL array of text). */
+export function textArray(name: string) {
+  return col<string[]>(name, 'TEXT[]')
+}
+/** Vector column for pgvector (embedding storage). Requires `dimensions`. */
+export function vector(name: string, dims: number) {
+  return col<number[]>(name, `vector(${dims})`)
+}
+
+export interface PartitionByDef {
+  type: 'RANGE' | 'LIST' | 'HASH'
+  column: string
+}
+
+export function partitionBy(type: 'range' | 'list' | 'hash', column: string): PartitionByDef {
+  return { type: type.toUpperCase() as 'RANGE' | 'LIST' | 'HASH', column }
+}
+
+/**
+ * Create a pair of `created_at` / `updated_at` timestamp columns
+ * that default to `NOW()` and are NOT NULL.
+ *
+ * ```ts
+ * pgTable('users', {
+ *   id: serial('id').primaryKey(),
+ *   name: text('name'),
+ *   ...timestamps(),
+ * })
+ * ```
+ */
+export function timestamps() {
+  return {
+    created_at: timestamptz('created_at')
+      .notNull()
+      .default(sql`NOW()`),
+    updated_at: timestamptz('updated_at')
+      .notNull()
+      .default(sql`NOW()`),
+  } as const
+}
+
+/**
+ * Convert a ColumnBuilder into a DDL column definition string.
+ *
+ * ```ts
+ * toDDL(text('name').notNull())
+ * // '"name" TEXT NOT NULL'
+ * ```
+ */
+export function toDDL(col: ColumnBuilder<unknown>): string {
+  const parts = [`"${col.name}"`, col.sqlType]
+  if (col.isPrimaryKey) parts.push('PRIMARY KEY')
+  if (!col.isPrimaryKey && !col.isNullable) parts.push('NOT NULL')
+  if (col.isUnique) parts.push('UNIQUE')
+  if (col.defaultExpr) parts.push(`DEFAULT ${col.defaultExpr}`)
+  if (col.ref) {
+    parts.push(`REFERENCES "${col.ref.table}"("${col.ref.column}")`)
+    if (col.ref.onDelete) parts.push(`ON DELETE ${col.ref.onDelete.toUpperCase()}`)
+  }
+  return parts.join(' ')
+}

package/postgres/schema/index.ts

@@ -0,0 +1,36 @@
+export { sql, SQL } from './sql.ts'
+export {
+  ColumnBuilder,
+  serial,
+  uuid,
+  text,
+  integer,
+  boolean as boolean,
+  boolean_,
+  timestamptz,
+  jsonb,
+  textArray,
+  vector,
+  toDDL,
+  partitionBy,
+  timestamps,
+} from './columns.ts'
+export type { PartitionByDef } from './columns.ts'
+export { pgTable, Table, BoundTable } from './table.ts'
+export type { IndexOptions, FindOptions, CreateOptions } from './table.ts'
+export {
+  eq,
+  ne,
+  gt,
+  gte,
+  lt,
+  lte,
+  isNull,
+  isNotNull,
+  like,
+  contains,
+  in_,
+  and,
+  or,
+  not,
+} from './where.ts'