weifuwu 0.25.2 → 0.27.0

package/graphql.ts

@@ -0,0 +1,267 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, no-console */
+import {
+  buildSchema,
+  graphql as executeGraphQL,
+  type GraphQLSchema,
+  validate as validateQuery,
+  parse,
+  type DocumentNode,
+} from 'graphql'
+import { makeExecutableSchema } from '@graphql-tools/schema'
+import type { Context } from './types.ts'
+import { Router } from './core/router.ts'
+import { currentTraceId } from './core/trace.ts'
+
+export interface GraphQLOptions {
+  schema: string | GraphQLSchema
+  rootValue?: any
+  resolvers?: any
+  context?: (req: Request, ctx: Context) => Record<string, any> | Promise<Record<string, any>>
+  graphiql?: boolean
+  /** Max query depth (nesting). Default: 10. Set 0 to disable. */
+  maxDepth?: number
+  /** Execution timeout in ms. Default: 30_000. */
+  timeout?: number
+}
+
+export type GraphQLHandler = (
+  req: Request,
+  ctx: Context,
+) => GraphQLOptions | Promise<GraphQLOptions>
+
+type GraphQLParams = {
+  query: string
+  variables: Record<string, any>
+  operationName?: string
+}
+
+function parseParamsFromGet(url: URL): GraphQLParams | null {
+  const query = url.searchParams.get('query')
+  if (!query) return null
+  let variables = {}
+  const variablesStr = url.searchParams.get('variables')
+  if (variablesStr) {
+    try {
+      variables = JSON.parse(variablesStr)
+    } catch {
+      return null
+    }
+  }
+  return { query, variables, operationName: url.searchParams.get('operationName') || undefined }
+}
+
+async function parseParamsFromPost(req: Request): Promise<GraphQLParams | null> {
+  try {
+    const body = (await req.json()) as {
+      query?: string
+      variables?: Record<string, any>
+      operationName?: string
+    }
+    if (!body.query) return null
+    return { query: body.query, variables: body.variables || {}, operationName: body.operationName }
+  } catch {
+    return null
+  }
+}
+
+function buildSchemaFromOptions(options: GraphQLOptions): GraphQLSchema {
+  try {
+    if (typeof options.schema === 'string') {
+      return options.resolvers
+        ? makeExecutableSchema({ typeDefs: options.schema, resolvers: options.resolvers })
+        : buildSchema(options.schema)
+    }
+    return options.schema
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    console.error(`[graphql] schema build failed: ${msg}`)
+    throw err
+  }
+}
+
+/** Count max nesting depth of a GraphQL query. */
+function queryDepth(doc: DocumentNode): number {
+  let max = 0
+  function walk(node: any, depth: number) {
+    if (depth > max) max = depth
+    if (node.selectionSet) {
+      for (const sel of node.selectionSet.selections) {
+        walk(sel, depth + 1)
+      }
+    }
+  }
+  for (const def of doc.definitions) {
+    if (def.kind === 'OperationDefinition') {
+      walk(def, 0)
+    }
+  }
+  return max
+}
+
+async function executeQuery(
+  schema: GraphQLSchema,
+  params: GraphQLParams,
+  options: GraphQLOptions,
+  req: Request,
+  ctx: Context,
+): Promise<Response> {
+  // Depth limit
+  const maxDepth = options.maxDepth ?? 10
+  if (maxDepth > 0) {
+    try {
+      const doc = parse(params.query)
+      const depth = queryDepth(doc)
+      if (depth > maxDepth) {
+        return Response.json(
+          { errors: [{ message: `Query depth ${depth} exceeds limit ${maxDepth}` }] },
+          { status: 400 },
+        )
+      }
+      const validationErrors = validateQuery(schema, doc)
+      if (validationErrors.length > 0) {
+        return Response.json(
+          { errors: validationErrors.map((e) => ({ message: e.message })) },
+          { status: 400 },
+        )
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      return Response.json({ errors: [{ message: `Parse error: ${msg}` }] }, { status: 400 })
+    }
+  }
+
+  // Timeout
+  const timeout = options.timeout ?? 30_000
+  const contextValue = options.context ? await options.context(req, ctx) : ctx
+
+  try {
+    const resultPromise = executeGraphQL({
+      schema,
+      source: params.query,
+      rootValue: options.rootValue,
+      contextValue,
+      variableValues: params.variables,
+      operationName: params.operationName,
+    }) as any
+
+    let result
+    if (timeout > 0) {
+      let timer: ReturnType<typeof setTimeout> | null = null
+      const timeoutPromise = new Promise<never>((_, reject) => {
+        timer = setTimeout(() => reject(new Error('Query timeout')), timeout)
+      })
+      result = await Promise.race([resultPromise, timeoutPromise])
+      if (timer) clearTimeout(timer)
+    } else {
+      result = await resultPromise
+    }
+
+    return Response.json(result, { status: result.errors ? 400 : 200 })
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    console.error(`[${currentTraceId()}] graphql execution failed: ${msg}`)
+    return Response.json({ errors: [{ message: msg }] }, { status: 500 })
+  }
+}
+
+function graphiqlHTML(endpoint: string): string {
+  const safeEndpoint = endpoint.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/</g, '\\x3C')
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>GraphiQL</title>
+    <style>body { margin: 0; } #graphiql { height: 100dvh; }</style>
+    <link rel="stylesheet" href="https://esm.sh/graphiql@5.2.2/dist/style.css" />
+    <script type="importmap">
+      {
+        "imports": {
+          "react": "https://esm.sh/react@19.2.5",
+          "react/": "https://esm.sh/react@19.2.5/",
+          "react-dom": "https://esm.sh/react-dom@19.2.5",
+          "react-dom/": "https://esm.sh/react-dom@19.2.5/",
+          "graphiql": "https://esm.sh/graphiql@5.2.2?standalone&external=react,react-dom,@graphiql/react,graphql",
+          "graphiql/": "https://esm.sh/graphiql@5.2.2/",
+          "@graphiql/react": "https://esm.sh/@graphiql/react@0.37.3?standalone&external=react,react-dom,graphql,@graphiql/toolkit,@emotion/is-prop-valid",
+          "@graphiql/toolkit": "https://esm.sh/@graphiql/toolkit@0.11.3?standalone&external=graphql",
+          "graphql": "https://esm.sh/graphql@16.13.2",
+          "@emotion/is-prop-valid": "data:text/javascript,"
+        }
+      }
+    </script>
+    <script type="module">
+      import React from 'react';
+      import ReactDOM from 'react-dom/client';
+      import { GraphiQL } from 'graphiql';
+      import { createGraphiQLFetcher } from '@graphiql/toolkit';
+      import 'graphiql/setup-workers/esm.sh';
+
+      const fetcher = createGraphiQLFetcher({ url: "${safeEndpoint}" });
+
+      function App() {
+        return React.createElement(GraphiQL, { fetcher });
+      }
+
+      const container = document.getElementById('graphiql');
+      const root = ReactDOM.createRoot(container);
+      root.render(React.createElement(App));
+    </script>
+  </head>
+  <body>
+    <div id="graphiql">Loading\u2026</div>
+  </body>
+</html>`
+}
+
+export function graphql(handler: GraphQLHandler): Router {
+  const r = new Router()
+  let cachedOptions: GraphQLOptions | null = null
+  let cachedSchema: GraphQLSchema | null = null
+
+  async function getSchema(
+    req: Request,
+    ctx: Context,
+  ): Promise<{ options: GraphQLOptions; schema: GraphQLSchema }> {
+    const options = await handler(req, ctx)
+    // Cache schema — handler must return the same schema reference for cache to work.
+    // If schema changes (e.g. hot-reload), return a different object reference.
+    if (cachedSchema && cachedOptions === options) {
+      return { options, schema: cachedSchema }
+    }
+    const schema = buildSchemaFromOptions(options)
+    cachedOptions = options
+    cachedSchema = schema
+    return { options, schema }
+  }
+
+  r.get('/', async (req, ctx) => {
+    const { options, schema } = await getSchema(req, ctx)
+    const url = new URL(req.url)
+
+    if (options.graphiql && !url.searchParams.has('query')) {
+      return new Response(graphiqlHTML(url.pathname), {
+        status: 200,
+        headers: { 'Content-Type': 'text/html' },
+      })
+    }
+
+    const params = parseParamsFromGet(url)
+    if (!params) {
+      return Response.json({ errors: [{ message: 'Missing query' }] }, { status: 400 })
+    }
+
+    return executeQuery(schema, params, options, req, ctx)
+  })
+
+  r.post('/', async (req, ctx) => {
+    const { options, schema } = await getSchema(req, ctx)
+    const params = await parseParamsFromPost(req)
+    if (!params) {
+      return Response.json({ errors: [{ message: 'Missing query' }] }, { status: 400 })
+    }
+    return executeQuery(schema, params, options, req, ctx)
+  })
+
+  return r
+}

package/hub.ts

@@ -0,0 +1,133 @@
+import type { Redis, WebSocket, Closeable } from './types.ts'
+
+/** Options for {@link createHub}. */
+export interface HubOptions {
+  /** Optional Redis client for cross-process pub/sub broadcast. */
+  redis?: Redis
+  /** Key prefix for Redis channels (default: `'hub:'`). */
+  prefix?: string
+}
+
+/**
+ * In-memory (and optionally Redis-backed) pub/sub hub for WebSocket rooms.
+ *
+ * Used internally by the WebSocket handler to implement `ctx.ws.join()` / `ctx.ws.sendRoom()`. */
+export interface Hub extends Closeable {
+  /** Subscribe a WebSocket to a room/group. */
+  join(key: string, ws: WebSocket): void
+  /** Unsubscribe a WebSocket from all rooms. */
+  leave(ws: WebSocket): void
+  /** Send a JSON message to all members of a room. */
+  broadcast(key: string, data: unknown): void
+  /** Close the hub, disconnect Redis subscribers, clear all rooms. */
+  close(): Promise<void>
+}
+
+/**
+ * Create a pub/sub hub for WebSocket room management.
+ *
+ * In-memory by default. Pass `redis` to enable cross-process broadcasting.
+ *
+ * ```ts
+ * import { createHub } from 'weifuwu'
+ *
+ * const hub = createHub()
+ * hub.join('room:general', ws)
+ * hub.broadcast('room:general', { type: 'chat', text: 'Hello' })
+ * ```
+ */
+export function createHub(opts?: HubOptions): Hub {
+  const prefix = opts?.prefix ?? 'hub:'
+  const channels = new Map<string, Set<WebSocket>>()
+  const wsKeys = new Map<WebSocket, Set<string>>()
+
+  let redisPub: Redis | undefined
+  let redisSub: Redis | null = null
+
+  if (opts?.redis) {
+    redisPub = opts.redis
+    redisSub = opts.redis.duplicate()
+    redisSub.on('message', (rawChannel: string, rawData: string) => {
+      if (!rawChannel.startsWith(prefix)) return
+      const key = rawChannel.slice(prefix.length)
+      const members = channels.get(key)
+      if (!members) return
+      for (const ws of members) {
+        try {
+          ws.send(rawData)
+        } catch {}
+      }
+    })
+  }
+
+  function join(key: string, ws: WebSocket): void {
+    if (!channels.has(key)) {
+      channels.set(key, new Set())
+      redisSub?.subscribe(`${prefix}${key}`)
+    }
+    channels.get(key)!.add(ws)
+    let keys = wsKeys.get(ws)
+    if (!keys) {
+      keys = new Set()
+      wsKeys.set(ws, keys)
+    }
+    keys.add(key)
+    // Auto-cleanup on close (if WebSocket supports addEventListener)
+    if (typeof ws.addEventListener === 'function') {
+      ws.addEventListener('close', () => removeFromChannels(ws))
+      ws.addEventListener('error', () => removeFromChannels(ws))
+    }
+  }
+
+  function removeFromChannels(ws: WebSocket): void {
+    const keys = wsKeys.get(ws)
+    if (keys) {
+      for (const key of keys) {
+        const members = channels.get(key)
+        if (members) {
+          members.delete(ws)
+          if (members.size === 0) channels.delete(key)
+        }
+      }
+      wsKeys.delete(ws)
+    }
+  }
+
+  function leave(ws: WebSocket): void {
+    removeFromChannels(ws)
+  }
+
+  function broadcast(key: string, data: unknown): void {
+    const msg = JSON.stringify(data)
+    const members = channels.get(key)
+    if (members) {
+      const dead: WebSocket[] = []
+      for (const ws of members) {
+        try {
+          ws.send(msg)
+        } catch {
+          dead.push(ws)
+        }
+      }
+      for (const ws of dead) removeFromChannels(ws)
+    }
+    redisPub?.publish(`${prefix}${key}`, msg)
+  }
+
+  async function close(): Promise<void> {
+    // Disconnect stale WebSocket listeners
+    for (const ws of wsKeys.keys()) {
+      removeFromChannels(ws)
+    }
+    channels.clear()
+    wsKeys.clear()
+    if (redisSub) {
+      redisSub.removeAllListeners('message')
+      await redisSub.quit()
+    }
+    redisPub = undefined
+    redisSub = null
+  }
+
+  return { join, leave, broadcast, close }
+}

package/index.ts

@@ -0,0 +1,71 @@
+export type { Context, Handler, Middleware, ErrorHandler } from './types.ts'
+export { HttpError } from './types.ts'
+export { currentTraceId, currentTrace, runWithTrace, traceElapsed, trace } from './core/trace.ts'
+export type { TraceContext, TraceInjected, TraceOptions } from './core/trace.ts'
+export { loadEnv, isDev, isProd, isBundled, getPublicEnv, env } from './core/env.ts'
+export { serve, createTestServer, DEFAULT_MAX_BODY } from './core/serve.ts'
+export type { ServeOptions, Server } from './core/serve.ts'
+export { Router } from './core/router.ts'
+export type { WebSocketHandler } from './core/router.ts'
+export { logger } from './core/logger.ts'
+export type { LoggerOptions } from './core/logger.ts'
+export { cors } from './middleware/cors.ts'
+export type { CORSOptions } from './middleware/cors.ts'
+
+export { serveStatic } from './middleware/static.ts'
+export type { ServeStaticOptions } from './middleware/static.ts'
+export { validate } from './middleware/validate.ts'
+export type { ValidationSchemas, ValidateModule } from './middleware/validate.ts'
+export { getCookies, setCookie, deleteCookie } from './core/cookie.ts'
+export type { CookieOptions } from './core/cookie.ts'
+export { upload } from './middleware/upload.ts'
+export type { UploadOptions, UploadedFile, UploadModule } from './middleware/upload.ts'
+export { rateLimit } from './middleware/rate-limit.ts'
+export type { RateLimitOptions } from './middleware/rate-limit.ts'
+export { compress } from './middleware/compress.ts'
+export type { CompressOptions } from './middleware/compress.ts'
+export { helmet } from './middleware/helmet.ts'
+export type { HelmetOptions } from './middleware/helmet.ts'
+export { requestId } from './middleware/request-id.ts'
+export type { RequestIdOptions, RequestIdModule } from './middleware/request-id.ts'
+export { createSSEStream, formatSSE, formatSSEData } from './core/sse.ts'
+export type { SSEEvent } from './core/sse.ts'
+export { testApp, TestApp, TestRequest, createTestDb, withTestDb } from './test/test-utils.ts'
+export type { TestResponse, TestDb } from './test/test-utils.ts'
+export { graphql } from './graphql.ts'
+export type { GraphQLOptions, GraphQLHandler } from './graphql.ts'
+export { aiStream } from './ai/stream.ts'
+export type { AIHandler } from './ai/stream.ts'
+export { aiProvider } from './ai/provider.ts'
+export type { AIProvider, AIProviderOptions, AIProviderInjected } from './ai/provider.ts'
+export {
+  streamText,
+  generateText,
+  generateObject,
+  streamObject,
+  tool,
+  embed,
+  embedMany,
+  smoothStream,
+} from 'ai'
+export { openai, createOpenAI } from '@ai-sdk/openai'
+export { postgres, MIGRATIONS_TABLE } from './postgres/index.ts'
+export type { PostgresOptions, PostgresClient, PostgresInjected } from './postgres/types.ts'
+export { redis } from './redis/index.ts'
+export type { RedisOptions, RedisClient, RedisInjected } from './redis/types.ts'
+export { createHub } from './hub.ts'
+export type { Hub, HubOptions } from './hub.ts'
+export { queue } from './queue/index.ts'
+export type { QueueOptions, QueueJob, Queue, QueueInjected } from './queue/types.ts'
+export { health } from './middleware/health.ts'
+export type { HealthOptions } from './middleware/health.ts'
+export { theme } from './middleware/theme.ts'
+export type { ThemeOptions, ThemeInjected } from './middleware/theme.ts'
+export { i18n } from './middleware/i18n.ts'
+export type { I18nOptions, I18nInjected } from './middleware/i18n.ts'
+export { flash } from './middleware/flash.ts'
+export type { FlashOptions, FlashInjected, FlashModule } from './middleware/flash.ts'
+export { mailer } from './mailer.ts'
+export type { MailerOptions, MailOptions, Mailer } from './mailer.ts'
+export { csrf } from './middleware/csrf.ts'
+export type { CsrfOptions, CsrfInjected, CsrfModule } from './middleware/csrf.ts'

package/mailer.ts

@@ -0,0 +1,81 @@
+import { createTransport, type Transporter } from 'nodemailer'
+import type { Closeable } from './types.ts'
+
+/** Options for sending an email. */
+export interface MailOptions {
+  /** Recipient address(es). */
+  to: string | string[]
+  /** Email subject. */
+  subject: string
+  /** Plain text body. */
+  text?: string
+  /** HTML body. */
+  html?: string
+  /** Sender address (overrides `MailerOptions.from`). */
+  from?: string
+  /** CC recipient(s). */
+  cc?: string | string[]
+  /** BCC recipient(s). */
+  bcc?: string | string[]
+}
+
+/** Options for {@link mailer}. */
+export interface MailerOptions {
+  /** Nodemailer transport string or pre-built transporter object. */
+  transport?: string | Transporter
+  /** Default sender address. */
+  from?: string
+  /** Custom send function (bypasses nodemailer). */
+  send?: (opts: MailOptions) => Promise<void>
+}
+
+/** Mailer instance returned by {@link mailer}. */
+export interface Mailer extends Closeable {
+  /** Send an email. */
+  send: (opts: MailOptions) => Promise<void>
+  /** Close the nodemailer transport. */
+  close: () => Promise<void>
+}
+
+/**
+ * Create a mailer instance.
+ *
+ * ```ts
+ * import { mailer } from 'weifuwu'
+ *
+ * const email = mailer({ transport: 'smtp://user:pass@smtp.example.com' })
+ * await email.send({
+ *   to: 'user@example.com',
+ *   subject: 'Hello',
+ *   text: 'Hello from weifuwu!',
+ * })
+ * await email.close()
+ * ```
+ */
+export function mailer(options: MailerOptions): Mailer {
+  const sender = options.send
+  const from = options.from
+
+  let transporter: Transporter | null = null
+  if (!sender && options.transport) {
+    transporter =
+      typeof options.transport === 'string' ? createTransport(options.transport) : options.transport
+  }
+
+  async function send(opts: MailOptions): Promise<void> {
+    if (sender) {
+      await sender(opts)
+      return
+    }
+    if (!transporter) {
+      throw new Error('mailer: no transport configured — provide `transport` or `send` option')
+    }
+    await transporter.sendMail({ ...opts, from: opts.from ?? from })
+  }
+
+  async function close(): Promise<void> {
+    transporter?.close()
+  }
+
+  return { send, close }
+}

package/middleware/compress.ts

@@ -0,0 +1,103 @@
+import { constants, brotliCompress, gzip, deflate } from 'node:zlib'
+import { promisify } from 'node:util'
+import type { Middleware } from '../types.ts'
+
+const brotliCompressAsync = promisify(brotliCompress)
+const gzipAsync = promisify(gzip)
+const deflateAsync = promisify(deflate)
+
+/** Options for {@link compress}. */
+export interface CompressOptions {
+  /** Compression level (1-9, default: 6). */
+  level?: number
+  /** Minimum response body size in bytes to compress (default: 1024). */
+  threshold?: number
+}
+
+/**
+ * Response compression middleware (brotli, gzip, deflate).
+ *
+ * Automatically selects the best encoding based on `Accept-Encoding` header.
+ * Skips compression for small responses, images, audio, video, and already-encoded responses.
+ *
+ * ```ts
+ * import { compress } from 'weifuwu'
+ * app.use(compress())
+ * ```
+ */
+export function compress(options?: CompressOptions): Middleware {
+  const level = options?.level ?? 6
+  const threshold = options?.threshold ?? 1024
+
+  return async (req, ctx, next) => {
+    const accept = req.headers.get('accept-encoding') ?? ''
+
+    const encoding = accept.includes('br')
+      ? 'br'
+      : accept.includes('gzip')
+        ? 'gzip'
+        : accept.includes('deflate')
+          ? 'deflate'
+          : ''
+
+    if (!encoding) return next(req, ctx)
+
+    const res = await next(req, ctx)
+
+    if (
+      res.status === 304 ||
+      res.status === 204 ||
+      res.status === 206 ||
+      res.status < 200 ||
+      res.status >= 300
+    ) {
+      return res
+    }
+
+    if (res.headers.get('content-encoding')) return res
+
+    const ct = res.headers.get('content-type') ?? ''
+    if (
+      !ct ||
+      ct.startsWith('audio/') ||
+      ct.startsWith('video/') ||
+      ct.startsWith('image/') ||
+      ct === 'application/zip'
+    ) {
+      return res
+    }
+
+    if (!res.body) return res
+
+    const body = await res.bytes()
+    if (body.byteLength < threshold) return res
+
+    let compressed: Buffer
+    try {
+      if (encoding === 'br') {
+        compressed = await brotliCompressAsync(body, {
+          params: { [constants.BROTLI_PARAM_QUALITY]: Math.min(level, 11) },
+        })
+      } else if (encoding === 'gzip') {
+        compressed = await gzipAsync(body, { level: Math.min(level, 9) })
+      } else {
+        compressed = await deflateAsync(body, { level: Math.min(level, 9) })
+      }
+    } catch {
+      return res
+    }
+
+    const headers = new Headers(res.headers)
+    headers.set('Content-Encoding', encoding)
+    headers.set('Content-Length', String(compressed.byteLength))
+    headers.delete('Content-Range')
+    const existingVary = headers.get('Vary')
+    headers.set('Vary', existingVary ? `${existingVary}, Accept-Encoding` : 'Accept-Encoding')
+
+    return new Response(compressed as BodyInit, {
+      status: res.status,
+      statusText: res.statusText,
+      headers,
+    })
+  }
+}