workmatic 1.0.5 → 1.1.0

package/dist/index.js

@@ -1,6 +1,7 @@
 // src/database.ts
 import Database from "better-sqlite3";
 import { Kysely, SqliteDialect } from "kysely";
+var kyselyToSqlite = /* @__PURE__ */ new WeakMap();
 function createDatabase(options = {}) {
   let sqliteDb;
   if (options.db) {
@@ -18,6 +19,7 @@ function createDatabase(options = {}) {
     })
   });
   createSchema(sqliteDb);
+  kyselyToSqlite.set(db, sqliteDb);
   return db;
 }
 function createSchema(db) {
@@ -53,6 +55,26 @@ function createSchema(db) {
       updated_at INTEGER NOT NULL
     )
   `);
+  db.exec(`
+    UPDATE workmatic_jobs SET status = 'dead' WHERE status = 'failed'
+  `);
+}
+function getUnderlyingDb(db) {
+  const mapped = kyselyToSqlite.get(db);
+  if (mapped) {
+    return mapped;
+  }
+  try {
+    const ex = db.getExecutor?.();
+    const dialect = ex?.adapter?.db;
+    if (dialect) {
+      return dialect;
+    }
+  } catch {
+  }
+  throw new Error(
+    "getUnderlyingDb: could not resolve better-sqlite3 instance (use createDatabase() or pass db from it)"
+  );
 }
 
 // src/client.ts
@@ -121,6 +143,42 @@ function createClient(options) {
       }).execute();
       return { ok: true, id: publicId };
     },
+    async addMany(payloads, opts = {}) {
+      const {
+        priority = 0,
+        delayMs = 0,
+        maxAttempts = 3
+      } = opts;
+      if (payloads.length === 0) {
+        return { ok: true, ids: [] };
+      }
+      const timestamp = now();
+      const runAt = timestamp + delayMs;
+      return await db.transaction().execute(async (trx) => {
+        const ids = [];
+        const rows = payloads.map((payload) => {
+          const payloadJson = validatePayload(payload);
+          const publicId = nanoid();
+          ids.push(publicId);
+          return {
+            public_id: publicId,
+            queue,
+            payload: payloadJson,
+            status: "ready",
+            priority,
+            run_at: runAt,
+            attempts: 0,
+            max_attempts: maxAttempts,
+            lease_until: 0,
+            created_at: timestamp,
+            updated_at: timestamp,
+            last_error: null
+          };
+        });
+        await trx.insertInto("workmatic_jobs").values(rows).execute();
+        return { ok: true, ids };
+      });
+    },
     /**
      * Get job statistics for the queue
      */
@@ -133,7 +191,6 @@ function createClient(options) {
         ready: 0,
         running: 0,
         done: 0,
-        failed: 0,
         dead: 0,
         total: 0
       };
@@ -164,6 +221,30 @@ function createClient(options) {
 // src/worker.ts
 import fastq from "fastq";
 import { sql as sql2 } from "kysely";
+var DEFAULT_WORKER_TIMEOUT_MS = 6e4;
+function parseClaimedRows(result) {
+  const rows = result.rows;
+  if (!rows || !Array.isArray(rows)) {
+    return [];
+  }
+  return rows.map((row) => ({
+    id: row.id,
+    public_id: row.public_id,
+    queue: row.queue,
+    payload: row.payload,
+    attempts: row.attempts,
+    max_attempts: row.max_attempts,
+    priority: row.priority,
+    created_at: row.created_at,
+    last_error: row.last_error
+  }));
+}
+function requireProcessor(processor) {
+  if (!processor) {
+    throw new Error("No processor set");
+  }
+  return processor;
+}
 function createWorker(options) {
   const {
     db,
@@ -171,10 +252,13 @@ function createWorker(options) {
     concurrency = 1,
     leaseMs = 3e4,
     pollMs = 1e3,
-    timeoutMs,
+    timeoutMs = DEFAULT_WORKER_TIMEOUT_MS,
     backoff = defaultBackoff,
     persistState = false,
-    autoRestore = true
+    autoRestore = true,
+    pauseCheckIntervalMs = 300,
+    requeueExpiredIntervalMs = 0,
+    onPumpError
   } = options;
   if (!db) {
     throw new Error("Database instance is required");
@@ -184,6 +268,13 @@ function createWorker(options) {
   let processor = null;
   let pumpTimeout = null;
   let fastqQueue = null;
+  let lastPauseCheckAt = 0;
+  let cachedDbPaused = false;
+  let lastRequeueAt = 0;
+  function notifyPumpError(error) {
+    console.error("[workmatic] Pump error:", error);
+    onPumpError?.(error);
+  }
   function getStateKey() {
     return `worker_state_${queue}`;
   }
@@ -191,8 +282,6 @@ function createWorker(options) {
     if (!persistState) return;
     const timestamp = now();
     const key = getStateKey();
-    await db.schema.createTable("workmatic_settings").ifNotExists().addColumn("queue", "text", (col) => col.primaryKey()).addColumn("paused", "integer", (col) => col.notNull().defaultTo(0)).addColumn("updated_at", "integer", (col) => col.notNull()).execute().catch(() => {
-    });
     await sql2`
       INSERT INTO workmatic_settings (queue, paused, updated_at)
       VALUES (${key}, ${state === "paused" ? 1 : state === "running" ? 2 : 0}, ${timestamp})
@@ -227,17 +316,20 @@ function createWorker(options) {
     const timestamp = now();
     const leaseUntil = timestamp + leaseMs;
     return await db.transaction().execute(async (trx) => {
-      const jobs = await trx.selectFrom("workmatic_jobs").select(["id", "public_id", "queue", "payload", "attempts", "max_attempts"]).where("queue", "=", queue).where("status", "=", "ready").where("run_at", "<=", timestamp).orderBy("priority", "asc").orderBy("id", "asc").limit(limit).execute();
-      if (jobs.length === 0) {
-        return [];
-      }
-      const jobIds = jobs.map((j) => j.id);
-      await trx.updateTable("workmatic_jobs").set({
-        status: "running",
-        lease_until: leaseUntil,
-        updated_at: timestamp
-      }).where("id", "in", jobIds).execute();
-      return jobs;
+      const result = await sql2`
+        UPDATE workmatic_jobs
+        SET status = 'running', lease_until = ${leaseUntil}, updated_at = ${timestamp}
+        WHERE rowid IN (
+          SELECT rowid FROM workmatic_jobs
+          WHERE queue = ${queue}
+            AND status = 'ready'
+            AND run_at <= ${timestamp}
+          ORDER BY priority ASC, id ASC
+          LIMIT ${limit}
+        )
+        RETURNING id, public_id, queue, payload, attempts, max_attempts, priority, created_at, last_error
+      `.execute(trx);
+      return parseClaimedRows(result);
     });
   }
   async function markDone(jobId) {
@@ -285,28 +377,24 @@ function createWorker(options) {
     }
   }
   async function processJob(claimedJob) {
-    if (!processor) {
-      throw new Error("No processor set");
-    }
+    const fn = requireProcessor(processor);
     const payload = parsePayload(claimedJob.payload);
     const job = {
       id: claimedJob.public_id,
       queue: claimedJob.queue,
       payload,
       status: "running",
-      priority: 0,
-      // Not needed for processing
+      priority: claimedJob.priority,
       attempts: claimedJob.attempts,
       maxAttempts: claimedJob.max_attempts,
-      createdAt: 0,
-      // Not needed for processing
-      lastError: null
+      createdAt: claimedJob.created_at,
+      lastError: claimedJob.last_error
     };
     try {
       if (timeoutMs) {
-        await withTimeout(processor(job), timeoutMs, job.id);
+        await withTimeout(fn(job), timeoutMs, job.id);
       } else {
-        await processor(job);
+        await fn(job);
       }
       await markDone(claimedJob.id);
     } catch (error) {
@@ -331,12 +419,21 @@ function createWorker(options) {
       return;
     }
     try {
-      const dbPaused = await isQueuePausedInDb();
-      if (dbPaused) {
+      const t = now();
+      if (t - lastPauseCheckAt >= pauseCheckIntervalMs) {
+        lastPauseCheckAt = t;
+        cachedDbPaused = await isQueuePausedInDb();
+      }
+      if (cachedDbPaused) {
         pumpTimeout = setTimeout(pump, pollMs);
         return;
       }
-      await requeueExpiredLeases();
+      if (requeueExpiredIntervalMs <= 0 || t - lastRequeueAt >= requeueExpiredIntervalMs) {
+        if (requeueExpiredIntervalMs > 0) {
+          lastRequeueAt = t;
+        }
+        await requeueExpiredLeases();
+      }
       const batchSize = concurrency * 2;
       const jobs = await claimBatch(batchSize);
       if (jobs.length > 0) {
@@ -348,7 +445,7 @@ function createWorker(options) {
         pumpTimeout = setTimeout(pump, pollMs);
       }
     } catch (error) {
-      console.error("[workmatic] Pump error:", error);
+      notifyPumpError(error);
       pumpTimeout = setTimeout(pump, pollMs);
     }
   }
@@ -404,7 +501,6 @@ function createWorker(options) {
         ready: 0,
         running: 0,
         done: 0,
-        failed: 0,
         dead: 0,
         total: 0
       };
@@ -456,12 +552,211 @@ function createWorker(options) {
   return worker;
 }
 
+// src/orchestrator.ts
+import { sql as sql3 } from "kysely";
+var DEFAULT_TRANSFER_STATUSES = ["ready", "dead"];
+var DEFAULT_TRANSFER_LIMIT = 1e4;
+function rowsUpdated(result) {
+  const row = result[0];
+  return Number(row?.numUpdatedRows ?? 0);
+}
+function normalizeStatuses(status) {
+  if (!status) return [...DEFAULT_TRANSFER_STATUSES];
+  return Array.isArray(status) ? status : [status];
+}
+function createOrchestrator(options) {
+  const { db } = options;
+  if (!db) {
+    throw new Error("Database instance is required");
+  }
+  const registry = /* @__PURE__ */ new Map();
+  function ensureEntry(queue) {
+    let entry = registry.get(queue);
+    if (!entry) {
+      entry = { client: createClient({ db, queue }) };
+      registry.set(queue, entry);
+    }
+    return entry;
+  }
+  async function setQueuePaused(queue, paused) {
+    const timestamp = now();
+    const value = paused ? 1 : 0;
+    await sql3`
+      INSERT INTO workmatic_settings (queue, paused, updated_at)
+      VALUES (${queue}, ${value}, ${timestamp})
+      ON CONFLICT(queue) DO UPDATE SET
+        paused = ${value},
+        updated_at = ${timestamp}
+    `.execute(db);
+  }
+  async function selectJobIds(from, status, limit) {
+    const rows = await db.selectFrom("workmatic_jobs").select("id").where("queue", "=", from).where("status", "=", status).orderBy("priority", "asc").orderBy("id", "asc").limit(limit).execute();
+    return rows.map((r) => r.id);
+  }
+  async function transferReady(from, to, limit) {
+    const ids = await selectJobIds(from, "ready", limit);
+    if (ids.length === 0) return 0;
+    const timestamp = now();
+    const result = await db.updateTable("workmatic_jobs").set({ queue: to, updated_at: timestamp }).where("id", "in", ids).execute();
+    return rowsUpdated(result);
+  }
+  async function transferDead(from, to, limit, resetForRetry) {
+    const ids = await selectJobIds(from, "dead", limit);
+    if (ids.length === 0) return 0;
+    const timestamp = now();
+    if (resetForRetry) {
+      const result2 = await db.updateTable("workmatic_jobs").set({
+        queue: to,
+        status: "ready",
+        attempts: 0,
+        lease_until: 0,
+        last_error: null,
+        updated_at: timestamp,
+        run_at: timestamp
+      }).where("id", "in", ids).execute();
+      return rowsUpdated(result2);
+    }
+    const result = await db.updateTable("workmatic_jobs").set({ queue: to, updated_at: timestamp }).where("id", "in", ids).execute();
+    return rowsUpdated(result);
+  }
+  async function transferOtherStatus(from, to, status, limit) {
+    const ids = await selectJobIds(from, status, limit);
+    if (ids.length === 0) return 0;
+    const timestamp = now();
+    const result = await db.updateTable("workmatic_jobs").set({ queue: to, updated_at: timestamp }).where("id", "in", ids).execute();
+    return rowsUpdated(result);
+  }
+  const orchestrator = {
+    register(queue, opts = {}) {
+      const client = createClient({ db, queue });
+      let worker;
+      if (opts.worker) {
+        worker = createWorker({ db, queue, ...opts.worker });
+      }
+      registry.set(queue, { client, worker });
+      return client;
+    },
+    client(queue) {
+      return ensureEntry(queue).client;
+    },
+    worker(queue) {
+      const entry = registry.get(queue);
+      if (!entry?.worker) {
+        throw new Error(`No worker registered for queue "${queue}"`);
+      }
+      return entry.worker;
+    },
+    workers() {
+      return [...registry.values()].map((e) => e.worker).filter((w) => w !== void 0);
+    },
+    async queues() {
+      const rows = await db.selectFrom("workmatic_jobs").select("queue").distinct().execute();
+      const names = new Set(rows.map((r) => r.queue));
+      for (const name of registry.keys()) {
+        names.add(name);
+      }
+      return [...names].sort();
+    },
+    process(queue, fn) {
+      this.worker(queue).process(fn);
+    },
+    startAll() {
+      for (const entry of registry.values()) {
+        entry.worker?.start();
+      }
+    },
+    async stopAll() {
+      const stops = [...registry.values()].map((e) => e.worker?.stop()).filter((p) => p !== void 0);
+      await Promise.all(stops);
+    },
+    async pause(queue) {
+      const entry = registry.get(queue);
+      entry?.worker?.pause();
+      await setQueuePaused(queue, true);
+    },
+    async resume(queue) {
+      const entry = registry.get(queue);
+      entry?.worker?.resume();
+      await setQueuePaused(queue, false);
+    },
+    async isPaused(queue) {
+      const setting = await db.selectFrom("workmatic_settings").select("paused").where("queue", "=", queue).executeTakeFirst();
+      return setting?.paused === 1;
+    },
+    async stats(queueName) {
+      const names = queueName ? [queueName] : await this.queues();
+      const result = {};
+      for (const name of names) {
+        result[name] = await ensureEntry(name).client.stats();
+      }
+      return result;
+    },
+    async transfer(opts) {
+      const { from, to, resetForRetry = false } = opts;
+      if (from === to) {
+        return { moved: 0 };
+      }
+      const statuses = normalizeStatuses(opts.status);
+      let remaining = opts.limit ?? DEFAULT_TRANSFER_LIMIT;
+      let moved = 0;
+      if (statuses.includes("ready") && remaining > 0) {
+        const n = await transferReady(from, to, remaining);
+        moved += n;
+        remaining -= n;
+      }
+      if (statuses.includes("dead") && remaining > 0) {
+        const n = await transferDead(from, to, remaining, resetForRetry);
+        moved += n;
+        remaining -= n;
+      }
+      for (const status of statuses) {
+        if (status === "ready" || status === "dead" || remaining <= 0) continue;
+        const n = await transferOtherStatus(from, to, status, remaining);
+        moved += n;
+        remaining -= n;
+      }
+      return { moved };
+    },
+    async moveJob(publicId, toQueue, opts = {}) {
+      const allowed = normalizeStatuses(opts.status);
+      const row = await db.selectFrom("workmatic_jobs").select(["id", "queue", "status"]).where("public_id", "=", publicId).executeTakeFirst();
+      if (!row) {
+        throw new Error(`Job not found: ${publicId}`);
+      }
+      if (row.queue === toQueue) {
+        return;
+      }
+      if (!allowed.includes(row.status)) {
+        throw new Error(
+          `Job ${publicId} has status "${row.status}" and cannot be moved (allowed: ${allowed.join(", ")})`
+        );
+      }
+      const timestamp = now();
+      const resetForRetry = opts.resetForRetry ?? false;
+      if (row.status === "dead" && resetForRetry) {
+        await db.updateTable("workmatic_jobs").set({
+          queue: toQueue,
+          status: "ready",
+          attempts: 0,
+          lease_until: 0,
+          last_error: null,
+          updated_at: timestamp,
+          run_at: timestamp
+        }).where("public_id", "=", publicId).execute();
+        return;
+      }
+      await db.updateTable("workmatic_jobs").set({ queue: toQueue, updated_at: timestamp }).where("public_id", "=", publicId).execute();
+    }
+  };
+  return orchestrator;
+}
+
 // src/dashboard.ts
 import { createServer } from "http";
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
 import { readFile } from "fs/promises";
-import { sql as sql3 } from "kysely";
+import { sql as sql4 } from "kysely";
 var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = dirname(__filename2);
 var CONTENT_TYPES = {
@@ -470,6 +765,13 @@ var CONTENT_TYPES = {
   ".js": "application/javascript; charset=utf-8",
   ".json": "application/json; charset=utf-8"
 };
+function requestUrl(url) {
+  return url || "";
+}
+function staticContentTypeFor(filePath) {
+  const ext = filePath.substring(filePath.lastIndexOf(".")) || ".html";
+  return CONTENT_TYPES[ext] || "application/octet-stream";
+}
 function createRequestHandler(db, workerMap, basePath = "") {
   function sendJson(res, data, status = 200) {
     res.writeHead(status, { "Content-Type": "application/json" });
@@ -492,7 +794,7 @@ function createRequestHandler(db, workerMap, basePath = "") {
     return path;
   }
   async function handleGetJobs(req, res) {
-    const query = parseQuery(req.url || "");
+    const query = parseQuery(requestUrl(req.url));
     const queueFilter = query.get("queue");
     const statusFilter = query.get("status");
     const limit = Math.min(parseInt(query.get("limit") || "50", 10), 100);
@@ -533,11 +835,11 @@ function createRequestHandler(db, workerMap, basePath = "") {
     sendJson(res, { jobs: apiJobs, limit, offset });
   }
   async function handleGetStats(req, res) {
-    const query = parseQuery(req.url || "");
+    const query = parseQuery(requestUrl(req.url));
     const queueFilter = query.get("queue");
     let statsQuery = db.selectFrom("workmatic_jobs").select([
       "status",
-      sql3`count(*)`.as("count")
+      sql4`count(*)`.as("count")
     ]).groupBy("status");
     if (queueFilter) {
       statsQuery = statsQuery.where("queue", "=", queueFilter);
@@ -547,7 +849,6 @@ function createRequestHandler(db, workerMap, basePath = "") {
       ready: 0,
       running: 0,
       done: 0,
-      failed: 0,
       dead: 0,
       total: 0
     };
@@ -620,8 +921,7 @@ function createRequestHandler(db, workerMap, basePath = "") {
   async function serveStatic(res, filePath) {
     const dashboardDir = join(__dirname2, "..", "dashboard");
     const fullPath = join(dashboardDir, filePath);
-    const ext = filePath.substring(filePath.lastIndexOf(".")) || ".html";
-    const contentType = CONTENT_TYPES[ext] || "application/octet-stream";
+    const contentType = staticContentTypeFor(filePath);
     try {
       const content = await readFile(fullPath, "utf-8");
       res.writeHead(200, { "Content-Type": contentType });
@@ -631,21 +931,21 @@ function createRequestHandler(db, workerMap, basePath = "") {
     }
   }
   return async function handleRequest(req, res, next) {
-    const path = getPath(req.url || "/");
-    const fullUrl = req.url || "/";
-    if (basePath && !fullUrl.startsWith(basePath)) {
-      if (next) next();
-      return false;
-    }
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
-    if (req.method === "OPTIONS") {
-      res.writeHead(204);
-      res.end();
-      return true;
-    }
     try {
+      const path = getPath(req.url || "/");
+      const fullUrl = req.url || "/";
+      if (basePath && !fullUrl.startsWith(basePath)) {
+        if (next) next();
+        return false;
+      }
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return true;
+      }
       if (path === "/api/jobs" && req.method === "GET") {
         await handleGetJobs(req, res);
         return true;
@@ -705,11 +1005,7 @@ function createDashboard(options) {
   }
   const handleRequest = createRequestHandler(db, workerMap);
   const server = createServer((req, res) => {
-    handleRequest(req, res).catch((error) => {
-      console.error("[workmatic] Unhandled error:", error);
-      res.writeHead(500, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: "Internal server error" }));
-    });
+    void handleRequest(req, res);
   });
   server.listen(port);
   return {
@@ -741,24 +1037,19 @@ function createDashboardMiddleware(options) {
   }
   const handleRequest = createRequestHandler(db, workerMap, basePath);
   return (req, res, next) => {
-    handleRequest(req, res, next).catch((error) => {
-      console.error("[workmatic] Unhandled error:", error);
-      if (next) {
-        next();
-      } else {
-        res.writeHead(500, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "Internal server error" }));
-      }
-    });
+    void handleRequest(req, res, next);
   };
 }
 export {
+  DEFAULT_WORKER_TIMEOUT_MS,
   createClient,
   createDashboard,
   createDashboardMiddleware,
   createDatabase,
+  createOrchestrator,
   createWorker,
   defaultBackoff,
+  getUnderlyingDb,
   validatePayload
 };
 //# sourceMappingURL=index.js.map