pglite-queue 0.1.0

package/dist/index.js

@@ -0,0 +1,759 @@
+// src/queue.ts
+import { PGlite } from "@electric-sql/pglite";
+
+// src/types.ts
+function rowToJob(row) {
+  return {
+    id: row.id,
+    task: row.task,
+    data: row.data,
+    status: row.status,
+    priority: row.priority,
+    runAt: new Date(row.run_at),
+    startedAt: row.started_at ? new Date(row.started_at) : null,
+    completedAt: row.completed_at ? new Date(row.completed_at) : null,
+    failedAt: row.failed_at ? new Date(row.failed_at) : null,
+    attempts: row.attempts,
+    maxAttempts: row.max_attempts,
+    lastError: row.last_error,
+    progress: row.progress,
+    result: row.result,
+    cronExpr: row.cron_expr,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at)
+  };
+}
+
+// src/events.ts
+import { EventEmitter } from "events";
+var TypedEmitter = class {
+  emitter = new EventEmitter();
+  on(event, listener) {
+    this.emitter.on(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+    return this;
+  }
+  once(event, listener) {
+    this.emitter.once(event, listener);
+    return this;
+  }
+  emit(event, ...args) {
+    return this.emitter.emit(event, ...args);
+  }
+  removeAllListeners(event) {
+    this.emitter.removeAllListeners(event);
+    return this;
+  }
+};
+
+// src/backoff.ts
+function calculateBackoff(attempt, options) {
+  const type = options?.type ?? "exponential";
+  const baseDelay = options?.baseDelay ?? 1e3;
+  const maxDelay = options?.maxDelay ?? 3e5;
+  const factor = options?.factor ?? 2;
+  if (type === "fixed") {
+    return baseDelay;
+  }
+  const exponential = baseDelay * Math.pow(factor, attempt - 1);
+  const jitter = exponential * Math.random() * 0.25;
+  return Math.min(Math.round(exponential + jitter), maxDelay);
+}
+
+// src/cron.ts
+var FIELDS = [
+  { min: 0, max: 59 },
+  // minute
+  { min: 0, max: 23 },
+  // hour
+  { min: 1, max: 31 },
+  // day of month
+  { min: 1, max: 12 },
+  // month
+  { min: 0, max: 6 }
+  // day of week
+];
+function parseField(field, def) {
+  const values = /* @__PURE__ */ new Set();
+  for (const part of field.split(",")) {
+    const trimmed = part.trim();
+    if (trimmed === "*") {
+      for (let i = def.min; i <= def.max; i++) values.add(i);
+      continue;
+    }
+    const stepMatch = trimmed.match(/^(?:(\d+)-(\d+)|\*)\/(\d+)$/);
+    if (stepMatch) {
+      const start = stepMatch[1] !== void 0 ? parseInt(stepMatch[1], 10) : def.min;
+      const end = stepMatch[2] !== void 0 ? parseInt(stepMatch[2], 10) : def.max;
+      const step = parseInt(stepMatch[3] || "1", 10);
+      if (step === 0) throw new Error(`Invalid cron step: "${trimmed}"`);
+      for (let i = start; i <= end; i += step) values.add(i);
+      continue;
+    }
+    const rangeStepMatch = trimmed.match(/^(\d+)-(\d+)\/(\d+)$/);
+    if (rangeStepMatch) {
+      const start = parseInt(rangeStepMatch[1], 10);
+      const end = parseInt(rangeStepMatch[2], 10);
+      const step = parseInt(rangeStepMatch[3], 10);
+      if (step === 0) throw new Error(`Invalid cron step: "${trimmed}"`);
+      for (let i = start; i <= end; i += step) values.add(i);
+      continue;
+    }
+    const rangeMatch = trimmed.match(/^(\d+)-(\d+)$/);
+    if (rangeMatch) {
+      const start = parseInt(rangeMatch[1], 10);
+      const end = parseInt(rangeMatch[2], 10);
+      for (let i = start; i <= end; i++) values.add(i);
+      continue;
+    }
+    const num = parseInt(trimmed, 10);
+    if (isNaN(num) || num < def.min || num > def.max) {
+      throw new Error(`Invalid cron value "${trimmed}" for range ${def.min}-${def.max}`);
+    }
+    values.add(num);
+  }
+  return values;
+}
+function parseCron(expr) {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    throw new Error(`Invalid cron expression: "${expr}". Expected 5 fields (minute hour dom month dow).`);
+  }
+  const minutes = parseField(parts[0], FIELDS[0]);
+  const hours = parseField(parts[1], FIELDS[1]);
+  const doms = parseField(parts[2], FIELDS[2]);
+  const months = parseField(parts[3], FIELDS[3]);
+  const dows = parseField(parts[4], FIELDS[4]);
+  function matches(date) {
+    return minutes.has(date.getUTCMinutes()) && hours.has(date.getUTCHours()) && doms.has(date.getUTCDate()) && months.has(date.getUTCMonth() + 1) && dows.has(date.getUTCDay());
+  }
+  function nextRun(from) {
+    const d = from ? new Date(from.getTime()) : /* @__PURE__ */ new Date();
+    d.setUTCSeconds(0, 0);
+    d.setUTCMinutes(d.getUTCMinutes() + 1);
+    const limit = d.getTime() + 4 * 365 * 24 * 60 * 60 * 1e3;
+    while (d.getTime() < limit) {
+      if (!months.has(d.getUTCMonth() + 1)) {
+        d.setUTCMonth(d.getUTCMonth() + 1, 1);
+        d.setUTCHours(0, 0, 0, 0);
+        continue;
+      }
+      if (!doms.has(d.getUTCDate()) || !dows.has(d.getUTCDay())) {
+        d.setUTCDate(d.getUTCDate() + 1);
+        d.setUTCHours(0, 0, 0, 0);
+        continue;
+      }
+      if (!hours.has(d.getUTCHours())) {
+        d.setUTCHours(d.getUTCHours() + 1, 0, 0, 0);
+        continue;
+      }
+      if (!minutes.has(d.getUTCMinutes())) {
+        d.setUTCMinutes(d.getUTCMinutes() + 1, 0, 0);
+        continue;
+      }
+      return d;
+    }
+    throw new Error(`No matching cron time found within 4 years for expression: "${expr}"`);
+  }
+  return { nextRun, matches };
+}
+
+// src/worker.ts
+var FETCH_SQL = `
+UPDATE pglite_queue_jobs
+SET status = 'active', started_at = NOW(), attempts = attempts + 1
+WHERE id = (
+  SELECT id FROM pglite_queue_jobs
+  WHERE status IN ('pending', 'delayed')
+    AND run_at <= NOW()
+  ORDER BY priority ASC, run_at ASC, id ASC
+  LIMIT 1
+  FOR UPDATE SKIP LOCKED
+)
+RETURNING *;
+`;
+var COMPLETE_SQL = `
+UPDATE pglite_queue_jobs
+SET status = 'completed', completed_at = NOW(), result = $2, progress = 100
+WHERE id = $1
+RETURNING *;
+`;
+var FAIL_SQL = `
+UPDATE pglite_queue_jobs
+SET status = 'failed', failed_at = NOW(), last_error = $2
+WHERE id = $1
+RETURNING *;
+`;
+var RETRY_SQL = `
+UPDATE pglite_queue_jobs
+SET status = 'delayed', failed_at = NOW(), last_error = $2, run_at = NOW() + make_interval(secs => $3::double precision)
+WHERE id = $1
+RETURNING *;
+`;
+var PROGRESS_SQL = `
+UPDATE pglite_queue_jobs SET progress = $2 WHERE id = $1;
+`;
+var INSERT_CRON_NEXT_SQL = `
+INSERT INTO pglite_queue_jobs (task, data, status, priority, run_at, max_attempts, cron_expr, cron_name)
+VALUES ($1, $2, 'delayed', $3, $4, $5, $6, $7)
+ON CONFLICT (cron_name) WHERE cron_name IS NOT NULL AND status NOT IN ('completed', 'failed')
+DO UPDATE SET run_at = EXCLUDED.run_at, data = EXCLUDED.data;
+`;
+var Worker = class {
+  db;
+  handlers;
+  emitter;
+  concurrency;
+  activeCount = 0;
+  stopping = false;
+  pollInProgress = false;
+  pollQueued = false;
+  drainResolve = null;
+  constructor(db, options) {
+    this.db = db;
+    this.handlers = options.handlers;
+    this.emitter = options.emitter;
+    this.concurrency = options.concurrency;
+  }
+  async poll() {
+    if (this.stopping) return;
+    if (this.pollInProgress) {
+      this.pollQueued = true;
+      return;
+    }
+    this.pollInProgress = true;
+    try {
+      await this.doPoll();
+    } catch {
+    } finally {
+      this.pollInProgress = false;
+      if (this.pollQueued && !this.stopping) {
+        this.pollQueued = false;
+        void this.poll();
+      }
+    }
+  }
+  async doPoll() {
+    while (this.activeCount < this.concurrency && !this.stopping) {
+      const row = await this.fetchOne();
+      if (!row) break;
+      const entry = this.handlers.get(row.task);
+      if (!entry) {
+        await this.db.query(
+          `UPDATE pglite_queue_jobs SET status = 'pending', started_at = NULL, attempts = attempts - 1 WHERE id = $1`,
+          [row.id]
+        );
+        continue;
+      }
+      this.activeCount++;
+      const job = rowToJob(row);
+      this.emitter.emit("active", job);
+      void this.processJob(row, entry).finally(() => {
+        this.activeCount--;
+        if (this.activeCount === 0 && this.drainResolve) {
+          this.drainResolve();
+          this.drainResolve = null;
+        }
+        if (!this.stopping) {
+          void this.poll();
+        }
+      });
+    }
+    if (this.activeCount === 0) {
+      this.emitter.emit("drained");
+    }
+  }
+  async fetchOne() {
+    const result = await this.db.query(FETCH_SQL);
+    return result.rows[0] ?? null;
+  }
+  async processJob(row, entry) {
+    const context = {
+      id: row.id,
+      task: row.task,
+      data: row.data,
+      attempts: row.attempts,
+      maxAttempts: row.max_attempts,
+      progress: async (pct) => {
+        if (this.stopping) return;
+        const clamped = Math.max(0, Math.min(100, Math.round(pct)));
+        try {
+          await this.db.query(PROGRESS_SQL, [row.id, clamped]);
+          this.emitter.emit("progress", rowToJob({ ...row, progress: clamped }), clamped);
+        } catch {
+        }
+      }
+    };
+    try {
+      const result = await entry.handler(context);
+      if (this.stopping) return;
+      try {
+        const completedResult = await this.db.query(COMPLETE_SQL, [
+          row.id,
+          result !== void 0 ? JSON.stringify(result) : null
+        ]);
+        const completedJob = rowToJob(completedResult.rows[0]);
+        this.emitter.emit("completed", completedJob);
+        if (row.cron_expr) {
+          await this.scheduleNextCron(row);
+        }
+      } catch {
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      if (this.stopping) return;
+      try {
+        if (row.attempts < row.max_attempts) {
+          const backoffMs = calculateBackoff(row.attempts);
+          const backoffSecs = backoffMs / 1e3;
+          const retryResult = await this.db.query(RETRY_SQL, [row.id, error.message, backoffSecs]);
+          const retryJob = rowToJob(retryResult.rows[0]);
+          this.emitter.emit("retrying", retryJob, row.attempts);
+        } else {
+          const failResult = await this.db.query(FAIL_SQL, [row.id, error.message]);
+          const failedJob = rowToJob(failResult.rows[0]);
+          this.emitter.emit("failed", failedJob, error);
+        }
+        if (row.cron_expr) {
+          await this.scheduleNextCron(row);
+        }
+      } catch {
+      }
+    }
+  }
+  async scheduleNextCron(row) {
+    try {
+      const cron = parseCron(row.cron_expr);
+      const nextRun = cron.nextRun();
+      await this.db.query(INSERT_CRON_NEXT_SQL, [
+        row.task,
+        JSON.stringify(row.data),
+        row.priority,
+        nextRun.toISOString(),
+        row.max_attempts,
+        row.cron_expr,
+        row.cron_name
+      ]);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.emitter.emit("error", error);
+    }
+  }
+  waitForDrain() {
+    if (this.activeCount === 0) return Promise.resolve();
+    return new Promise((resolve) => {
+      this.drainResolve = resolve;
+    });
+  }
+  stop() {
+    this.stopping = true;
+  }
+  get active() {
+    return this.activeCount;
+  }
+  get isStopping() {
+    return this.stopping;
+  }
+};
+
+// src/schema.ts
+var MIGRATION_SQL = `
+CREATE TABLE IF NOT EXISTS pglite_queue_jobs (
+  id            BIGSERIAL PRIMARY KEY,
+  task          TEXT NOT NULL,
+  data          JSONB NOT NULL DEFAULT '{}'::jsonb,
+  status        TEXT NOT NULL DEFAULT 'pending',
+  priority      INTEGER NOT NULL DEFAULT 0,
+  run_at        TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  started_at    TIMESTAMPTZ,
+  completed_at  TIMESTAMPTZ,
+  failed_at     TIMESTAMPTZ,
+  attempts      INTEGER NOT NULL DEFAULT 0,
+  max_attempts  INTEGER NOT NULL DEFAULT 1,
+  last_error    TEXT,
+  progress      INTEGER NOT NULL DEFAULT 0 CHECK (progress >= 0 AND progress <= 100),
+  result        JSONB,
+  cron_expr     TEXT,
+  cron_name     TEXT,
+  created_at    TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  updated_at    TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_pglite_queue_pickup
+  ON pglite_queue_jobs (priority ASC, run_at ASC, id ASC)
+  WHERE status IN ('pending', 'delayed');
+
+CREATE INDEX IF NOT EXISTS idx_pglite_queue_task
+  ON pglite_queue_jobs (task);
+
+CREATE INDEX IF NOT EXISTS idx_pglite_queue_status
+  ON pglite_queue_jobs (status);
+
+DO $$ BEGIN
+  IF NOT EXISTS (
+    SELECT 1 FROM pg_indexes
+    WHERE indexname = 'idx_pglite_queue_cron_name'
+  ) THEN
+    CREATE UNIQUE INDEX idx_pglite_queue_cron_name
+      ON pglite_queue_jobs (cron_name)
+      WHERE cron_name IS NOT NULL AND status NOT IN ('completed', 'failed');
+  END IF;
+END $$;
+
+CREATE OR REPLACE FUNCTION pglite_queue_update_timestamp()
+RETURNS TRIGGER AS $$
+BEGIN
+  NEW.updated_at = NOW();
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+DO $$ BEGIN
+  IF NOT EXISTS (
+    SELECT 1 FROM pg_trigger WHERE tgname = 'trg_pglite_queue_updated_at'
+  ) THEN
+    CREATE TRIGGER trg_pglite_queue_updated_at
+      BEFORE UPDATE ON pglite_queue_jobs
+      FOR EACH ROW
+      EXECUTE FUNCTION pglite_queue_update_timestamp();
+  END IF;
+END $$;
+
+CREATE OR REPLACE FUNCTION pglite_queue_notify_new_job()
+RETURNS TRIGGER AS $$
+BEGIN
+  PERFORM pg_notify('pglite_queue_new_job', NEW.id::text);
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+DO $$ BEGIN
+  IF NOT EXISTS (
+    SELECT 1 FROM pg_trigger WHERE tgname = 'trg_pglite_queue_notify'
+  ) THEN
+    CREATE TRIGGER trg_pglite_queue_notify
+      AFTER INSERT ON pglite_queue_jobs
+      FOR EACH ROW
+      EXECUTE FUNCTION pglite_queue_notify_new_job();
+  END IF;
+END $$;
+`;
+var RECOVERY_SQL = `
+UPDATE pglite_queue_jobs
+SET
+  status = CASE
+    WHEN attempts >= max_attempts THEN 'failed'
+    ELSE 'pending'
+  END,
+  started_at = NULL,
+  last_error = COALESCE(last_error, 'Process crashed during execution')
+WHERE status = 'active';
+`;
+async function runMigrations(db) {
+  await db.exec(MIGRATION_SQL);
+}
+async function recoverStalledJobs(db) {
+  const result = await db.query(RECOVERY_SQL);
+  return result.affectedRows ?? 0;
+}
+
+// src/delay.ts
+var UNITS = {
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+function parseDelay(input) {
+  if (typeof input === "number") return input;
+  const match = input.trim().match(/^(\d+(?:\.\d+)?)\s*(s|m|h|d)$/i);
+  if (!match) {
+    throw new Error(`Invalid delay format: "${input}". Use a number (ms) or a string like "5s", "10m", "2h", "1d".`);
+  }
+  const value = parseFloat(match[1]);
+  const unit = match[2].toLowerCase();
+  return Math.round(value * UNITS[unit]);
+}
+
+// src/queue.ts
+var ADD_JOB_SQL = `
+INSERT INTO pglite_queue_jobs (task, data, status, priority, run_at, max_attempts)
+VALUES ($1, $2, $3, $4, NOW() + make_interval(secs => $5::double precision), $6)
+RETURNING *;
+`;
+var ADD_CRON_SQL = `
+INSERT INTO pglite_queue_jobs (task, data, status, priority, run_at, max_attempts, cron_expr, cron_name)
+VALUES ($1, $2, 'delayed', $3, $4, $5, $6, $7)
+ON CONFLICT (cron_name) WHERE cron_name IS NOT NULL AND status NOT IN ('completed', 'failed')
+DO UPDATE SET run_at = EXCLUDED.run_at, data = EXCLUDED.data, cron_expr = EXCLUDED.cron_expr
+RETURNING *;
+`;
+var GET_JOB_SQL = `SELECT * FROM pglite_queue_jobs WHERE id = $1;`;
+var REMOVE_JOB_SQL = `DELETE FROM pglite_queue_jobs WHERE id = $1;`;
+var Queue = class {
+  db = null;
+  ownsDb;
+  dataDir;
+  concurrency;
+  pollInterval;
+  shutdownTimeout;
+  handleSignals;
+  handlers = /* @__PURE__ */ new Map();
+  emitter = new TypedEmitter();
+  worker = null;
+  pollTimer = null;
+  unsubscribeNotify = null;
+  started = false;
+  signalHandlers = [];
+  migrated = false;
+  constructor(options = {}) {
+    if (options.db) {
+      this.db = options.db;
+      this.ownsDb = false;
+      this.dataDir = "";
+    } else {
+      this.ownsDb = true;
+      this.dataDir = options.dataDir ?? "memory://";
+    }
+    this.concurrency = options.concurrency ?? 1;
+    this.pollInterval = options.pollInterval ?? 5e3;
+    this.shutdownTimeout = options.shutdownTimeout ?? 3e4;
+    this.handleSignals = options.handleSignals ?? false;
+  }
+  /**
+   * Register a job handler for a task name.
+   */
+  define(task, handler, options) {
+    this.handlers.set(task, {
+      handler,
+      concurrency: options?.concurrency
+    });
+  }
+  /**
+   * Add a job to the queue.
+   */
+  async add(task, data, options) {
+    const db = await this.ensureReady();
+    const delaySecs = options?.delay ? parseDelay(options.delay) / 1e3 : 0;
+    const status = delaySecs > 0 ? "delayed" : "pending";
+    const priority = options?.priority ?? 0;
+    const maxAttempts = (options?.retry ?? 0) + 1;
+    const result = await db.query(ADD_JOB_SQL, [
+      task,
+      JSON.stringify(data),
+      status,
+      priority,
+      delaySecs,
+      maxAttempts
+    ]);
+    return rowToJob(result.rows[0]);
+  }
+  /**
+   * Register a recurring cron job.
+   */
+  async every(cronExpr, task, data, options) {
+    const db = await this.ensureReady();
+    const cron = parseCron(cronExpr);
+    const nextRun = cron.nextRun();
+    const priority = options?.priority ?? 0;
+    const maxAttempts = (options?.retry ?? 0) + 1;
+    const result = await db.query(ADD_CRON_SQL, [
+      task,
+      JSON.stringify(data ?? {}),
+      priority,
+      nextRun.toISOString(),
+      maxAttempts,
+      cronExpr,
+      task
+      // cron_name defaults to task name
+    ]);
+    return rowToJob(result.rows[0]);
+  }
+  /**
+   * Start processing jobs.
+   */
+  async start() {
+    if (this.started) return;
+    this.started = true;
+    const db = await this.ensureReady();
+    const recovered = await recoverStalledJobs(db);
+    if (recovered > 0) {
+      this.emitter.emit("error", new Error(`Recovered ${recovered} stalled jobs from previous crash`));
+    }
+    this.worker = new Worker(db, {
+      concurrency: this.concurrency,
+      handlers: this.handlers,
+      emitter: this.emitter
+    });
+    try {
+      const unsub = await db.listen("pglite_queue_new_job", () => {
+        if (this.worker && !this.worker.isStopping) {
+          void this.worker.poll();
+        }
+      });
+      this.unsubscribeNotify = () => unsub();
+    } catch {
+    }
+    this.pollTimer = setInterval(() => {
+      if (this.worker && !this.worker.isStopping) {
+        void this.worker.poll();
+      }
+    }, this.pollInterval);
+    if (this.handleSignals) {
+      for (const signal of ["SIGINT", "SIGTERM"]) {
+        const handler = () => {
+          void this.stop();
+        };
+        process.on(signal, handler);
+        this.signalHandlers.push({ signal, handler });
+      }
+    }
+    void this.worker.poll();
+  }
+  /**
+   * Gracefully stop processing. Waits for active jobs to finish.
+   */
+  async stop() {
+    if (!this.started) return;
+    this.started = false;
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    if (this.unsubscribeNotify) {
+      this.unsubscribeNotify();
+      this.unsubscribeNotify = null;
+    }
+    if (this.worker) {
+      this.worker.stop();
+      if (this.worker.active > 0) {
+        const timeout = new Promise(
+          (resolve) => setTimeout(resolve, this.shutdownTimeout)
+        );
+        await Promise.race([this.worker.waitForDrain(), timeout]);
+      }
+    }
+    for (const { signal, handler } of this.signalHandlers) {
+      process.removeListener(signal, handler);
+    }
+    this.signalHandlers = [];
+    if (this.ownsDb && this.db) {
+      await this.db.close();
+      this.db = null;
+    }
+  }
+  /**
+   * Get a job by ID.
+   */
+  async getJob(id) {
+    const db = await this.ensureReady();
+    const result = await db.query(GET_JOB_SQL, [id]);
+    return result.rows[0] ? rowToJob(result.rows[0]) : null;
+  }
+  /**
+   * Get jobs matching a filter.
+   */
+  async getJobs(filter) {
+    const db = await this.ensureReady();
+    const conditions = [];
+    const params = [];
+    let paramIdx = 1;
+    if (filter?.status) {
+      const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+      conditions.push(`status = ANY($${paramIdx})`);
+      params.push(statuses);
+      paramIdx++;
+    }
+    if (filter?.task) {
+      conditions.push(`task = $${paramIdx}`);
+      params.push(filter.task);
+      paramIdx++;
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = filter?.limit ? `LIMIT ${filter.limit}` : "";
+    const offset = filter?.offset ? `OFFSET ${filter.offset}` : "";
+    const sql = `SELECT * FROM pglite_queue_jobs ${where} ORDER BY created_at DESC ${limit} ${offset};`;
+    const result = await db.query(sql, params);
+    return result.rows.map((row) => rowToJob(row));
+  }
+  /**
+   * Remove a job by ID.
+   */
+  async removeJob(id) {
+    const db = await this.ensureReady();
+    const result = await db.query(REMOVE_JOB_SQL, [id]);
+    return (result.affectedRows ?? 0) > 0;
+  }
+  /**
+   * Remove all completed/failed jobs.
+   */
+  async clean(status) {
+    const db = await this.ensureReady();
+    const statuses = status ? [status] : ["completed", "failed"];
+    const result = await db.query(
+      `DELETE FROM pglite_queue_jobs WHERE status = ANY($1);`,
+      [statuses]
+    );
+    return result.affectedRows ?? 0;
+  }
+  /**
+   * Delete all jobs (for testing).
+   */
+  async obliterate() {
+    const db = await this.ensureReady();
+    await db.exec("DELETE FROM pglite_queue_jobs;");
+  }
+  /**
+   * Get job counts by status.
+   */
+  async counts() {
+    const db = await this.ensureReady();
+    const result = await db.query(
+      `SELECT status, COUNT(*)::text as count FROM pglite_queue_jobs GROUP BY status;`
+    );
+    const counts = {};
+    for (const row of result.rows) {
+      counts[row.status] = parseInt(row.count, 10);
+    }
+    return counts;
+  }
+  // --- Event delegation ---
+  on(event, listener) {
+    this.emitter.on(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+    return this;
+  }
+  once(event, listener) {
+    this.emitter.once(event, listener);
+    return this;
+  }
+  // --- Internal ---
+  async ensureDb() {
+    if (!this.db) {
+      this.db = new PGlite(this.dataDir);
+      await this.db.waitReady;
+    }
+    return this.db;
+  }
+  async ensureReady() {
+    const db = await this.ensureDb();
+    if (!this.migrated) {
+      await runMigrations(db);
+      this.migrated = true;
+    }
+    return db;
+  }
+};
+export {
+  Queue,
+  calculateBackoff,
+  parseCron,
+  parseDelay
+};
+//# sourceMappingURL=index.js.map