weifuwu 0.27.2 → 0.27.3

package/queue/types.ts

@@ -1,60 +0,0 @@
-import type { Redis, Context, Middleware, Closeable } from '../types.ts'
-
-declare module '../types.ts' {
-  interface Context {
-    queue: Queue
-  }
-}
-
-export interface QueueJob<T = unknown> {
-  id: string
-  type: string
-  payload: T
-  createdAt: number
-  runAt: number
-  schedule?: string
-}
-
-export interface QueueOptions {
-  /** Backend store. Default: 'memory'. */
-  store?: 'memory' | 'pg' | 'redis'
-  redis?: Redis
-  url?: string
-  prefix?: string
-  pollInterval?: number
-  /** PostgreSQL client (required when store: 'pg'). */
-  pg?: { sql: import('../types.ts').SqlClient }
-}
-
-export interface QueueInjected {
-  queue: Queue
-}
-
-export interface QueueJobWithError<T = unknown> extends QueueJob<T> {
-  error: string
-  failedAt: number
-}
-
-export interface Queue extends Middleware<Context, Context & QueueInjected>, Closeable {
-  /** Register a cron job. Uses queue's backend (memory/pg/redis) for execution. */
-  cron(pattern: string, handler: () => void | Promise<void>): { stop: () => void }
-  add<T>(type: string, payload: T, opts?: { delay?: number; schedule?: string }): Promise<string>
-  process<T>(type: string, handler: (job: QueueJob<T>) => Promise<void>): void
-  run(): Promise<void>
-  stats(): {
-    running: boolean
-    inflight: number
-    processed: number
-    failed: number
-    handlers: number
-    maxConcurrent: number
-  }
-  jobs(limit?: number): Promise<QueueJob[]>
-  failedJobs(limit?: number): Promise<QueueJobWithError[]>
-  retryFailed(jobId: string): Promise<boolean>
-  retryAllFailed(type?: string): Promise<number>
-  dashboard(): import('../core/router.ts').Router
-  /** Create the jobs table (PG mode only; safe to call multiple times). */
-  migrate?(): Promise<void>
-  close(): Promise<void>
-}

package/redis/client.ts

@@ -1,24 +0,0 @@
-/* eslint-disable no-console */
-import { Redis as IORedis } from 'ioredis'
-import type { Context, Handler } from '../types.ts'
-import type { RedisOptions, RedisClient } from './types.ts'
-
-export function redis(opts?: string | RedisOptions): RedisClient {
-  const options: RedisOptions = typeof opts === 'string' ? { url: opts } : (opts ?? {})
-
-  const url = options.url ?? process.env.REDIS_URL ?? 'redis://localhost:6379'
-  const client = new IORedis(url, options)
-
-  client.on('error', (err: Error) => console.error('[redis]', err.message))
-
-  const mw = ((req: Request, ctx: Context, next: Handler) => {
-    ctx.redis = client
-    return next(req, ctx)
-  }) as unknown as RedisClient
-
-  mw.__meta = { injects: ['redis'], depends: [] }
-  mw.redis = client
-  mw.close = () => client.quit() as unknown as Promise<void>
-
-  return mw
-}

package/redis/types.ts

@@ -1,28 +0,0 @@
-import type {
-  Redis,
-  RedisOptions as IORedisOptions,
-  Context,
-  Middleware,
-  Closeable,
-} from '../types.ts'
-
-declare module '../types.ts' {
-  interface Context {
-    redis: Redis
-  }
-}
-
-export type { Redis }
-
-export type RedisOptions = IORedisOptions & {
-  url?: string
-}
-
-export interface RedisInjected {
-  redis: Redis
-}
-
-export interface RedisClient extends Middleware<Context, Context & RedisInjected>, Closeable {
-  redis: Redis
-  close: () => Promise<void>
-}

package/types.ts

@@ -1,78 +0,0 @@
-import type postgres from 'postgres'
-
-/** Untyped postgres.js SQL client. Use typed `Sql<{ table: { col: type } }>` for schemas. */
-export type SqlClient = postgres.Sql<Record<string, unknown>>
-
-/** Re-export for downstream usage. */
-export type { Sql } from 'postgres'
-export type { WebSocket } from 'ws'
-export type { Redis, RedisOptions } from 'ioredis'
-
-// Context — extensible via module augmentation.
-// Built-in middleware modules declare additional properties here.
-// e.g. postgres/types.ts → `declare module '../types.ts' { interface Context { sql: SqlClient } }`
-export interface Context {
-  params: Record<string, string>
-  query: Record<string, string>
-  mountPath?: string
-  [key: string]: unknown // allow arbitrary middleware-injected data
-}
-
-// Generic handler — T extends Context so middleware-injected properties are visible.
-// Default T = Context means no generics needed for simple cases.
-export type Handler<T extends Context = Context> = (
-  req: Request,
-  ctx: T,
-) => Response | Promise<Response>
-
-/**
- * Metadata for middleware dependency checking.
- * Middleware factories attach this for runtime validation.
- */
-export interface MiddlewareMeta {
-  /** Fields this middleware injects into ctx. */
-  injects: string[]
-  /** Fields this middleware depends on (must be injected earlier). */
-  depends: string[]
-}
-
-// Generic middleware — In receives accumulated context from previous middlewares,
-// Out adds new properties. next receives the enriched Out type.
-// Default In = Out = Context means backward-compatible.
-export type Middleware<In extends Context = Context, Out extends In = In> = {
-  (req: Request, ctx: In, next: Handler<Out>): Response | Promise<Response>
-  __meta?: MiddlewareMeta
-}
-
-export type ErrorHandler<T extends Context = Context> = (
-  error: Error,
-  req: Request,
-  ctx: T,
-) => Response | Promise<Response>
-
-/**
- * Interface for resources that require explicit cleanup (connections, pools, timers).
- * All stateful modules implement this.
- */
-export interface Closeable {
-  /** Release all resources. Call once when shutting down. */
-  close(): Promise<void>
-}
-
-/**
- * HTTP error with an explicit status code.
- * Throw from a handler or middleware to return a non-200 response.
- *
- * ```ts
- * if (!resource) throw new HttpError('Not found', 404)
- * serve() catches it and returns the status code.
- * ```
- */
-export class HttpError extends Error {
-  status: number
-  constructor(message: string, status: number) {
-    super(message)
-    this.name = 'HttpError'
-    this.status = status
-  }
-}