weifuwu 0.27.2 → 0.27.3

package/queue/index.ts

@@ -1,654 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars, no-console */
-import { Redis as IORedis } from 'ioredis'
-import crypto from 'node:crypto'
-import type { Context, Handler } from '../types.ts'
-import { Router } from '../core/router.ts'
-import type { Queue, QueueOptions, QueueJob, QueueJobWithError } from './types.ts'
-import { cronNext, parsePattern, matches } from './cron.ts'
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type JobHandler = (job: QueueJob<any>) => Promise<void>
-
-// ── Factory ─────────────────────────────────────────────────────────────────
-
-export function queue(opts?: QueueOptions): Queue {
-  const store = opts?.store ?? 'memory'
-
-  if (store === 'redis') return createRedisQueue(opts)
-  if (store === 'pg') return createPgQueue(opts)
-  return createMemoryQueue(opts)
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// Shared helpers
-// ═══════════════════════════════════════════════════════════════════════════════
-
-function escapeIdent(s: string): string {
-  return '"' + s.replace(/"/g, '""') + '"'
-}
-
-/** Adds cron() to a queue instance: uses process + add with schedule internally. */
-function attachCron(q: Queue, handlers: Map<string, JobHandler>): void {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  ;(q as any).cron = function (pattern: string, handler: () => void | Promise<void>) {
-    const id =
-      '__cron_' + pattern.replace(/[^a-zA-Z0-9]/g, '_') + '_' + crypto.randomUUID().slice(0, 8)
-    q.process(id, async () => {
-      await handler()
-    })
-    q.add(id, {}, { schedule: pattern })
-    return { stop: () => handlers.delete(id) }
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// Memory mode
-// ═══════════════════════════════════════════════════════════════════════════════
-
-function createMemoryQueue(opts?: QueueOptions): Queue {
-  const pollInterval = opts?.pollInterval ?? 200
-  const handlers = new Map<string, JobHandler>()
-  const pending: QueueJob[] = []
-  const failed: QueueJobWithError[] = []
-  const MAX_FAILED = 1000
-  let running = false
-  let pollTimer: ReturnType<typeof setTimeout> | null = null
-  let _processed = 0
-  let _failed = 0
-  let inflight = 0
-  const MAX_CONCURRENT = 16
-
-  function insertJob(job: QueueJob): void {
-    let i = 0
-    while (i < pending.length && pending[i].runAt <= job.runAt) i++
-    pending.splice(i, 0, job)
-  }
-
-  async function execute(job: QueueJob, handler: (job: QueueJob) => Promise<void>): Promise<void> {
-    inflight++
-    try {
-      await handler(job)
-      _processed++
-    } catch (e) {
-      _failed++
-      failed.unshift({ ...job, error: (e as Error).message, failedAt: Date.now() })
-      if (failed.length > MAX_FAILED) failed.length = MAX_FAILED
-    } finally {
-      inflight--
-    }
-    if (job.schedule) {
-      try {
-        insertJob({
-          ...job,
-          id: crypto.randomUUID(),
-          runAt: cronNext(job.schedule),
-          createdAt: Date.now(),
-        })
-      } catch (e) {
-        console.error('[queue] cron re-queue failed:', (e as Error).message)
-      }
-    }
-  }
-
-  async function poll(): Promise<void> {
-    if (!running) return
-    const now = Date.now()
-    while (running && inflight < MAX_CONCURRENT && pending.length > 0 && pending[0].runAt <= now) {
-      const job = pending.shift()!
-      const handler = handlers.get(job.type)
-      if (handler) execute(job, handler)
-    }
-    if (running) pollTimer = setTimeout(poll, pollInterval)
-  }
-
-  const mw = ((req: Request, ctx: Context, next: Handler) => {
-    ctx.queue = q
-    return next(req, ctx)
-  }) as unknown as Queue
-
-  const q: Queue = mw
-  mw.add = function add<T>(
-    type: string,
-    payload: T,
-    opts?: { delay?: number; schedule?: string },
-  ): Promise<string> {
-    const id = crypto.randomUUID()
-    let runAt: number
-    if (opts?.schedule) {
-      try {
-        const f = parsePattern(opts.schedule)
-        runAt = matches(f, new Date()) ? Date.now() : cronNext(opts.schedule)
-      } catch {
-        runAt = cronNext(opts.schedule)
-      }
-    } else if (opts?.delay) {
-      runAt = Date.now() + opts.delay
-    } else {
-      runAt = Date.now()
-    }
-    const job: QueueJob<T> = { id, type, payload, createdAt: Date.now(), runAt }
-    if (opts?.schedule) job.schedule = opts.schedule
-    insertJob(job)
-    return Promise.resolve(id)
-  }
-  mw.process = function process<T>(
-    type: string,
-    handler: (job: QueueJob<T>) => Promise<void>,
-  ): void {
-    handlers.set(type, handler)
-  }
-  mw.run = async function run(): Promise<void> {
-    if (running) return
-    running = true
-    poll()
-  }
-  mw.close = async function close(): Promise<void> {
-    running = false
-    if (pollTimer) {
-      clearTimeout(pollTimer)
-      pollTimer = null
-    }
-    while (inflight > 0) await new Promise((r) => setTimeout(r, 50))
-  }
-  mw.jobs = async function (limit?: number): Promise<QueueJob[]> {
-    return pending.slice(0, limit ?? 50)
-  }
-  mw.failedJobs = async function failedJobs(limit?: number): Promise<QueueJobWithError[]> {
-    return failed.slice(0, limit ?? 50)
-  }
-  mw.retryFailed = async function retry(jobId: string): Promise<boolean> {
-    const idx = failed.findIndex((j) => j.id === jobId)
-    if (idx < 0) return false
-    const [entry] = failed.splice(idx, 1)
-    _failed--
-    insertJob({ ...entry, runAt: Date.now() })
-    return true
-  }
-  mw.retryAllFailed = async function retryAll(type?: string): Promise<number> {
-    let count = 0
-    for (let i = failed.length - 1; i >= 0; i--) {
-      if (type && failed[i].type !== type) continue
-      const [entry] = failed.splice(i, 1)
-      _failed--
-      insertJob({ ...entry, runAt: Date.now() })
-      count++
-    }
-    return count
-  }
-  mw.dashboard = function dashboard(): Router {
-    return buildDashboard(q)
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  ;(mw as any).stats = () => ({
-    running,
-    inflight,
-    processed: _processed,
-    failed: _failed,
-    handlers: handlers.size,
-    maxConcurrent: MAX_CONCURRENT,
-  })
-
-  attachCron(q, handlers)
-  return q
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// PostgreSQL mode
-// ═══════════════════════════════════════════════════════════════════════════════
-
-function createPgQueue(opts?: QueueOptions): Queue {
-  const sql = opts!.pg!.sql
-  const pollInterval = opts?.pollInterval ?? 200
-  const table = (opts?.prefix ?? 'queue') + '_jobs'
-  const handlers = new Map<string, JobHandler>()
-  let running = false,
-    pollTimer: ReturnType<typeof setTimeout> | null = null
-  let _processed = 0,
-    _failed = 0,
-    inflight = 0,
-    ready = false
-  const MAX_CONCURRENT = 16
-  const MAX_FAILED = 1000
-
-  async function ensureTable(): Promise<void> {
-    if (ready) return
-    await sql.unsafe(
-      `CREATE TABLE IF NOT EXISTS ${escapeIdent(table)} (id UUID PRIMARY KEY, type TEXT NOT NULL, payload JSONB NOT NULL DEFAULT '{}', run_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), schedule TEXT, status TEXT NOT NULL DEFAULT 'pending', error TEXT, failed_at TIMESTAMPTZ, created_at TIMESTAMPTZ NOT NULL DEFAULT NOW())`,
-    )
-    await sql.unsafe(
-      `CREATE INDEX IF NOT EXISTS ${escapeIdent(table + '_run_at_idx')} ON ${escapeIdent(table)} (run_at, status)`,
-    )
-    ready = true
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async function processJob(job: any, handler: (job: any) => Promise<void>): Promise<void> {
-    inflight++
-    try {
-      await handler(job)
-      _processed++
-      await sql.unsafe(`DELETE FROM ${escapeIdent(table)} WHERE id = $1`, [job.id])
-    } catch (e) {
-      _failed++
-      const msg = (e as Error).message
-      console.error('[queue] handler error:', msg)
-      await sql.unsafe(
-        `UPDATE ${escapeIdent(table)} SET status = 'failed', error = $2, failed_at = NOW() WHERE id = $1`,
-        [job.id, msg],
-      )
-    } finally {
-      inflight--
-    }
-    if (job.schedule) {
-      try {
-        const nextRun = cronNext(job.schedule)
-        await sql.unsafe(
-          `INSERT INTO ${escapeIdent(table)} (id, type, payload, run_at, schedule) VALUES ($1, $2, $3::jsonb, $4, $5)`,
-          [
-            crypto.randomUUID(),
-            job.type,
-            JSON.stringify(job.payload),
-            new Date(nextRun).toISOString(),
-            job.schedule,
-          ],
-        )
-      } catch (e) {
-        console.error('[queue] cron re-queue failed:', (e as Error).message)
-      }
-    }
-  }
-
-  async function poll(): Promise<void> {
-    if (!running) return
-    try {
-      while (running && inflight < MAX_CONCURRENT) {
-        const rows = (await sql.unsafe(
-          `UPDATE ${escapeIdent(table)} SET status = 'running' WHERE id = (SELECT id FROM ${escapeIdent(table)} WHERE run_at <= NOW() AND status = 'pending' ORDER BY run_at LIMIT 1 FOR UPDATE SKIP LOCKED) RETURNING *`,
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        )) as any[]
-        if (rows.length === 0) break
-        const row = rows[0]
-        const job = {
-          id: row.id,
-          type: row.type,
-          payload: typeof row.payload === 'string' ? JSON.parse(row.payload) : row.payload,
-          createdAt: new Date(row.created_at).getTime(),
-          runAt: new Date(row.run_at).getTime(),
-          schedule: row.schedule || undefined,
-        }
-        const handler = handlers.get(job.type)
-        if (handler) processJob(job, handler)
-      }
-    } catch (e) {
-      const msg = (e as Error).message
-      if (msg.includes('CONNECTION_ENDED') || msg.includes('Connection terminated')) {
-        running = false
-        return
-      }
-      console.error('[queue] poll error:', msg)
-    }
-    if (running) pollTimer = setTimeout(poll, pollInterval)
-  }
-
-  const mw = ((req: Request, ctx: Context, next: Handler) => {
-    ctx.queue = q
-    return next(req, ctx)
-  }) as unknown as Queue
-  const q: Queue = mw
-  mw.add = function add<T>(
-    type: string,
-    payload: T,
-    opts?: { delay?: number; schedule?: string },
-  ): Promise<string> {
-    return (async () => {
-      const id = crypto.randomUUID()
-      let runAt: Date
-      if (opts?.schedule) {
-        try {
-          const f = parsePattern(opts.schedule)
-          runAt = matches(f, new Date()) ? new Date() : new Date(cronNext(opts.schedule))
-        } catch {
-          runAt = new Date(cronNext(opts.schedule))
-        }
-      } else if (opts?.delay) {
-        runAt = new Date(Date.now() + opts.delay)
-      } else {
-        runAt = new Date()
-      }
-      await sql.unsafe(
-        `INSERT INTO ${escapeIdent(table)} (id, type, payload, run_at, schedule) VALUES ($1, $2, $3::jsonb, $4, $5)`,
-        [id, type, JSON.stringify(payload), runAt.toISOString(), opts?.schedule || null],
-      )
-      return id
-    })()
-  }
-  mw.process = function process<T>(
-    type: string,
-    handler: (job: QueueJob<T>) => Promise<void>,
-  ): void {
-    handlers.set(type, handler)
-  }
-  mw.migrate = ensureTable
-  mw.run = async function run(): Promise<void> {
-    if (running) return
-    await ensureTable()
-    running = true
-    poll()
-  }
-  mw.close = async function close(): Promise<void> {
-    running = false
-    if (pollTimer) {
-      clearTimeout(pollTimer)
-      pollTimer = null
-    }
-    while (inflight > 0) await new Promise((r) => setTimeout(r, 50))
-  }
-  mw.jobs = async function jobs(limit?: number): Promise<QueueJob[]> {
-    const rows = (await sql.unsafe(
-      `SELECT * FROM ${escapeIdent(table)} WHERE status = 'pending' ORDER BY run_at LIMIT $1`,
-      [limit ?? 50],
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    )) as any[]
-    return rows.map((r) => ({
-      id: r.id,
-      type: r.type,
-      payload: typeof r.payload === 'string' ? JSON.parse(r.payload) : r.payload,
-      createdAt: new Date(r.created_at).getTime(),
-      runAt: new Date(r.run_at).getTime(),
-      schedule: r.schedule || undefined,
-    }))
-  }
-  mw.failedJobs = async function failedJobs(limit?: number): Promise<QueueJobWithError[]> {
-    const rows = (await sql.unsafe(
-      `SELECT * FROM ${escapeIdent(table)} WHERE status = 'failed' ORDER BY failed_at DESC LIMIT $1`,
-      [limit ?? 50],
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    )) as any[]
-    return rows.map((r) => ({
-      id: r.id,
-      type: r.type,
-      payload: typeof r.payload === 'string' ? JSON.parse(r.payload) : r.payload,
-      createdAt: new Date(r.created_at).getTime(),
-      runAt: new Date(r.run_at).getTime(),
-      schedule: r.schedule || undefined,
-      error: r.error || '',
-      failedAt: new Date(r.failed_at).getTime(),
-    }))
-  }
-  mw.retryFailed = async function retryFailed(jobId: string): Promise<boolean> {
-    const result = (await sql.unsafe(
-      `UPDATE ${escapeIdent(table)} SET status = 'pending', error = NULL, failed_at = NULL, run_at = NOW() WHERE id = $1 AND status = 'failed' RETURNING id`,
-      [jobId],
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    )) as any[]
-    return result.length > 0
-  }
-  mw.retryAllFailed = async function retryAllFailed(type?: string): Promise<number> {
-    const result = (await sql.unsafe(
-      type
-        ? `UPDATE ${escapeIdent(table)} SET status = 'pending', error = NULL, failed_at = NULL, run_at = NOW() WHERE status = 'failed' AND type = $1 RETURNING id`
-        : `UPDATE ${escapeIdent(table)} SET status = 'pending', error = NULL, failed_at = NULL, run_at = NOW() WHERE status = 'failed' RETURNING id`,
-      type ? [type] : [],
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    )) as any[]
-    return result.length
-  }
-  mw.dashboard = function dashboard(): Router {
-    return buildDashboard(q)
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  ;(mw as any).stats = () => ({
-    running,
-    inflight,
-    processed: _processed,
-    failed: _failed,
-    handlers: handlers.size,
-    maxConcurrent: MAX_CONCURRENT,
-  })
-
-  attachCron(q, handlers)
-  return q
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// Redis mode
-// ═══════════════════════════════════════════════════════════════════════════════
-
-function createRedisQueue(opts?: QueueOptions): Queue {
-  const redis =
-    opts?.redis ?? new IORedis(opts?.url ?? process.env.REDIS_URL ?? 'redis://localhost:6379')
-  const prefix = opts?.prefix ?? 'queue'
-  const pollInterval = opts?.pollInterval ?? 200
-  const handlers = new Map<string, JobHandler>()
-  let running = false,
-    pollTimer: ReturnType<typeof setTimeout> | null = null,
-    epoch = 0
-  let _processed = 0,
-    _failed = 0,
-    inflight = 0
-  const jobKey = prefix + ':jobs',
-    failedKey = prefix + ':failed',
-    MAX_FAILED = 1000,
-    MAX_CONCURRENT = 16
-
-  async function processJob(
-    job: QueueJob,
-    handler: (job: QueueJob) => Promise<void>,
-  ): Promise<void> {
-    inflight++
-    try {
-      await handler(job)
-      _processed++
-    } catch (e) {
-      _failed++
-      const msg = (e as Error).message
-      console.error('[queue] handler error:', msg)
-      await redis.lpush(failedKey, JSON.stringify({ ...job, error: msg, failedAt: Date.now() }))
-      await redis.ltrim(failedKey, 0, MAX_FAILED - 1)
-    } finally {
-      inflight--
-    }
-    if (job.schedule) {
-      try {
-        const nextRun = cronNext(job.schedule)
-        await redis.zadd(
-          jobKey,
-          nextRun,
-          JSON.stringify({
-            ...job,
-            id: crypto.randomUUID(),
-            runAt: nextRun,
-            createdAt: Date.now(),
-          }),
-        )
-      } catch (e) {
-        console.error('[queue] cron re-queue failed:', (e as Error).message)
-      }
-    }
-  }
-
-  async function poll(): Promise<void> {
-    const currentEpoch = epoch
-    if (!running) return
-    try {
-      const now = Date.now()
-      while (running && inflight < MAX_CONCURRENT) {
-        const result = await redis.zpopmin(jobKey)
-        if (result.length < 2) break
-        const raw = result[0],
-          score = parseInt(result[1], 10)
-        if (score > now) {
-          await redis.zadd(jobKey, score, raw)
-          break
-        }
-        let job: QueueJob
-        try {
-          job = JSON.parse(raw)
-        } catch {
-          continue
-        }
-        const handler = handlers.get(job.type)
-        if (handler) processJob(job, handler)
-      }
-    } catch (e) {
-      console.error('[queue] poll error:', (e as Error).message)
-    }
-    if (running && currentEpoch === epoch) pollTimer = setTimeout(poll, pollInterval)
-  }
-
-  const mw = ((req: Request, ctx: Context, next: Handler) => {
-    ctx.queue = q
-    return next(req, ctx)
-  }) as unknown as Queue
-  const q: Queue = mw
-  mw.add = function add<T>(
-    type: string,
-    payload: T,
-    opts?: { delay?: number; schedule?: string },
-  ): Promise<string> {
-    const id = crypto.randomUUID()
-    let runAt: number
-    if (opts?.schedule) {
-      runAt = cronNext(opts.schedule)
-    } else if (opts?.delay) {
-      runAt = Date.now() + opts.delay
-    } else {
-      runAt = Date.now()
-    }
-    const job: QueueJob<T> = { id, type, payload, createdAt: Date.now(), runAt }
-    if (opts?.schedule) job.schedule = opts.schedule
-    return redis.zadd(jobKey, runAt, JSON.stringify(job)).then(() => id)
-  }
-  mw.process = function process<T>(
-    type: string,
-    handler: (job: QueueJob<T>) => Promise<void>,
-  ): void {
-    handlers.set(type, handler)
-  }
-  mw.run = async function run(): Promise<void> {
-    if (running) return
-    running = true
-    poll()
-  }
-  mw.close = async function close(): Promise<void> {
-    running = false
-    epoch++
-    if (pollTimer) {
-      clearTimeout(pollTimer)
-      pollTimer = null
-    }
-    while (inflight > 0) await new Promise((r) => setTimeout(r, 50))
-    redis.disconnect()
-  }
-  mw.jobs = async function jobs(limit?: number): Promise<QueueJob[]> {
-    const raw = await redis.zrevrange(jobKey, 0, (limit ?? 50) - 1)
-    return raw
-      .map((r: string) => {
-        try {
-          return JSON.parse(r)
-        } catch {
-          return null
-        }
-      })
-      .filter(Boolean)
-  }
-  mw.failedJobs = async function failedJobs(limit?: number): Promise<QueueJobWithError[]> {
-    const raw = await redis.lrange(failedKey, 0, (limit ?? 50) - 1)
-    return raw
-      .map((r: string) => {
-        try {
-          return JSON.parse(r)
-        } catch {
-          return null
-        }
-      })
-      .filter(Boolean)
-  }
-  mw.retryFailed = async function retryFailed(jobId: string): Promise<boolean> {
-    const raw = await redis.lrange(failedKey, 0, -1)
-    for (const entry of raw) {
-      try {
-        const job = JSON.parse(entry)
-        if (job.id === jobId) {
-          await redis.lrem(failedKey, 1, entry)
-          const reJob = { ...job, runAt: Date.now() }
-          delete reJob.error
-          delete reJob.failedAt
-          await redis.zadd(jobKey, reJob.runAt, JSON.stringify(reJob))
-          _failed--
-          return true
-        }
-      } catch {}
-    }
-    return false
-  }
-  mw.retryAllFailed = async function retryAllFailed(type?: string): Promise<number> {
-    let count = 0
-    const raw = await redis.lrange(failedKey, 0, -1)
-    for (const entry of raw) {
-      try {
-        const job = JSON.parse(entry)
-        if (type && job.type !== type) continue
-        await redis.lrem(failedKey, 1, entry)
-        const reJob = { ...job, runAt: Date.now() }
-        delete reJob.error
-        delete reJob.failedAt
-        await redis.zadd(jobKey, reJob.runAt, JSON.stringify(reJob))
-        _failed--
-        count++
-      } catch {}
-    }
-    return count
-  }
-  mw.dashboard = function dashboard(): Router {
-    return buildDashboard(q)
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  ;(mw as any).stats = () => ({
-    running,
-    inflight,
-    processed: _processed,
-    failed: _failed,
-    handlers: handlers.size,
-    maxConcurrent: MAX_CONCURRENT,
-  })
-
-  attachCron(q, handlers)
-  return q
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// Shared dashboard
-// ═══════════════════════════════════════════════════════════════════════════════
-
-function buildDashboard(q: Queue): Router {
-  const r = new Router()
-  r.get('/', async () => {
-    const s = q.stats()
-    const pending = await q.jobs(100)
-    const byType: Record<string, { pending: number; failed: number }> = {}
-    for (const j of pending) {
-      if (!byType[j.type]) byType[j.type] = { pending: 0, failed: 0 }
-      byType[j.type].pending++
-    }
-    const failed = await q.failedJobs(1000)
-    for (const j of failed) {
-      if (!byType[j.type]) byType[j.type] = { pending: 0, failed: 0 }
-      byType[j.type].failed++
-    }
-    return Response.json({ stats: s, types: byType, failedCount: failed.length })
-  })
-  r.get('/:type/failed', async (req, ctx) => {
-    const failed = await q.failedJobs(100)
-    return Response.json({ jobs: failed.filter((j) => j.type === ctx.params.type) })
-  })
-  r.post('/:type/retry', async (req, ctx) => {
-    return Response.json({ retried: await q.retryAllFailed(ctx.params.type) })
-  })
-  r.post('/retry/:id', async (req, ctx) => {
-    const ok = await q.retryFailed(ctx.params.id)
-    if (!ok) return new Response('Not found', { status: 404 })
-    return Response.json({ ok: true })
-  })
-  return r
-}