@workglow/indexeddb 0.2.36 → 0.2.37

package/dist/job-queue/browser.js

@@ -1,28 +1,7 @@
 // src/job-queue/IndexedDbQueueStorage.ts
-import { createServiceToken, deepEqual, makeFingerprint, uuid4 } from "@workglow/util";
+import { JobStatus, validateLeaseMs } from "@workglow/job-queue";
 import { HybridSubscriptionManager } from "@workglow/storage";
-
-// src/storage/openIdb.ts
-function openIdb(dbName, options = {}) {
-  return new Promise((resolve, reject) => {
-    const req = indexedDB.open(dbName, options.version);
-    req.onsuccess = () => {
-      const db = req.result;
-      db.onversionchange = () => db.close();
-      resolve(db);
-    };
-    req.onupgradeneeded = (ev) => options.onUpgradeNeeded?.(ev);
-    req.onerror = () => {
-      const err = req.error;
-      if (err && err.name === "VersionError") {
-        reject(new Error(`IndexedDB ${dbName} exists at a higher version than ${options.version ?? "current"}`));
-        return;
-      }
-      reject(err);
-    };
-    req.onblocked = () => reject(new Error(`IndexedDB ${dbName} is blocked — close other tabs using this database.`));
-  });
-}
+import { createServiceToken, deepEqual, makeFingerprint, uuid4 } from "@workglow/util";
 
 // src/migrations/IndexedDbMigrationRunner.ts
 import {
@@ -317,6 +296,62 @@ function indexedDbQueueMigrations(tableName, prefixes) {
           });
         }
       }
+    },
+    {
+      component,
+      version: 2,
+      description: "Rename queue_status_run_after → queue_status_visible_at; backfill five legacy field renames (run_after → visible_at, run_attempts → attempts, last_ran_at → last_attempted_at, max_retries → max_attempts, worker_id → lease_owner)",
+      up({ tx }) {
+        const store = tx.objectStore(tableName);
+        const indexNames = Array.from(store.indexNames);
+        if (indexNames.includes("queue_status_run_after")) {
+          store.deleteIndex("queue_status_run_after");
+        }
+        const cursorReq = store.openCursor();
+        cursorReq.onsuccess = () => {
+          const cursor = cursorReq.result;
+          if (!cursor) {
+            if (!Array.from(store.indexNames).includes("queue_status_visible_at")) {
+              store.createIndex("queue_status_visible_at", k(["queue", "status", "visible_at"]), {
+                unique: false
+              });
+            }
+            return;
+          }
+          const row = cursor.value;
+          if (row) {
+            let dirty = false;
+            if (row.run_after !== undefined && row.visible_at === undefined) {
+              row.visible_at = row.run_after;
+              delete row.run_after;
+              dirty = true;
+            }
+            if (row.run_attempts !== undefined && row.attempts === undefined) {
+              row.attempts = row.run_attempts;
+              delete row.run_attempts;
+              dirty = true;
+            }
+            if (row.last_ran_at !== undefined && row.last_attempted_at === undefined) {
+              row.last_attempted_at = row.last_ran_at;
+              delete row.last_ran_at;
+              dirty = true;
+            }
+            if (row.max_retries !== undefined && row.max_attempts === undefined) {
+              row.max_attempts = row.max_retries;
+              delete row.max_retries;
+              dirty = true;
+            }
+            if (row.worker_id !== undefined && row.lease_owner === undefined) {
+              row.lease_owner = row.worker_id;
+              delete row.worker_id;
+              dirty = true;
+            }
+            if (dirty)
+              cursor.update(row);
+          }
+          cursor.continue();
+        };
+      }
     }
   ];
 }
@@ -327,8 +362,29 @@ function indexedDbQueueMigrationGroup(tableName, prefixes) {
   };
 }
 
+// src/storage/openIdb.ts
+function openIdb(dbName, options = {}) {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(dbName, options.version);
+    req.onsuccess = () => {
+      const db = req.result;
+      db.onversionchange = () => db.close();
+      resolve(db);
+    };
+    req.onupgradeneeded = (ev) => options.onUpgradeNeeded?.(ev);
+    req.onerror = () => {
+      const err = req.error;
+      if (err && err.name === "VersionError") {
+        reject(new Error(`IndexedDB ${dbName} exists at a higher version than ${options.version ?? "current"}`));
+        return;
+      }
+      reject(err);
+    };
+    req.onblocked = () => reject(new Error(`IndexedDB ${dbName} is blocked — close other tabs using this database.`));
+  });
+}
+
 // src/job-queue/IndexedDbQueueStorage.ts
-import { JobStatus } from "@workglow/job-queue";
 var INDEXED_DB_QUEUE_STORAGE = createServiceToken("jobqueue.storage.indexedDb");
 
 class IndexedDbQueueStorage {
@@ -399,7 +455,7 @@ class IndexedDbQueueStorage {
     jobWithPrefixes.progress_message = "";
     jobWithPrefixes.progress_details = null;
     jobWithPrefixes.created_at = now;
-    jobWithPrefixes.run_after = now;
+    jobWithPrefixes.visible_at = now;
     for (const [key, value] of Object.entries(this.prefixValues)) {
       jobWithPrefixes[key] = value;
     }
@@ -437,7 +493,7 @@ class IndexedDbQueueStorage {
     const db = await this.getDb();
     const tx = db.transaction(this.tableName, "readonly");
     const store = tx.objectStore(this.tableName);
-    const index = store.index("queue_status_run_after");
+    const index = store.index("queue_status_visible_at");
     const prefixKeyValues = this.getPrefixKeyValues();
     return new Promise((resolve, reject) => {
       const ret = new Map;
@@ -460,24 +516,44 @@ class IndexedDbQueueStorage {
       tx.onerror = () => reject(tx.error);
     });
   }
-  async next(workerId) {
+  async next(workerId, opts) {
+    const leaseMs = opts?.leaseMs ?? 30000;
+    validateLeaseMs(leaseMs, "leaseMs");
     const db = await this.getDb();
     const tx = db.transaction(this.tableName, "readwrite");
     const store = tx.objectStore(this.tableName);
-    const index = store.index("queue_status_run_after");
     const now = new Date().toISOString();
+    const leaseExpiry = new Date(Date.now() + leaseMs).toISOString();
     const prefixKeyValues = this.getPrefixKeyValues();
     const claimToken = workerId;
     const jobToReturn = await new Promise((resolve, reject) => {
-      const cursorRequest = index.openCursor(IDBKeyRange.bound([...prefixKeyValues, this.queueName, JobStatus.PENDING, ""], [...prefixKeyValues, this.queueName, JobStatus.PENDING, now], false, false));
       let claimedJob;
-      let cursorStopped = false;
-      cursorRequest.onsuccess = (e) => {
+      const tryClaimJob = (job) => {
+        const isLeaseExpiryReclaim = job.status === JobStatus.PROCESSING;
+        job.status = JobStatus.PROCESSING;
+        job.last_attempted_at = now;
+        job.lease_owner = claimToken;
+        job.lease_expires_at = leaseExpiry;
+        if (isLeaseExpiryReclaim) {
+          job.attempts = (job.attempts ?? 0) + 1;
+        }
+        job.abort_requested_at = null;
+        try {
+          const updateRequest = store.put(job);
+          updateRequest.onsuccess = () => {
+            claimedJob = job;
+          };
+          updateRequest.onerror = () => {};
+        } catch {}
+      };
+      const pendingIndex = store.index("queue_status_visible_at");
+      const pendingRequest = pendingIndex.openCursor(IDBKeyRange.bound([...prefixKeyValues, this.queueName, JobStatus.PENDING, ""], [...prefixKeyValues, this.queueName, JobStatus.PENDING, now], false, false));
+      pendingRequest.onsuccess = (e) => {
         const cursor = e.target.result;
         if (!cursor) {
-          return;
-        }
-        if (cursorStopped) {
+          if (!claimedJob) {
+            tryExpiredLeaseScan();
+          }
           return;
         }
         const job = cursor.value;
@@ -485,25 +561,29 @@ class IndexedDbQueueStorage {
           cursor.continue();
           return;
         }
-        job.status = JobStatus.PROCESSING;
-        job.last_ran_at = now;
-        job.worker_id = claimToken;
-        try {
-          const updateRequest = store.put(job);
-          updateRequest.onsuccess = () => {
-            claimedJob = job;
-            cursorStopped = true;
-          };
-          updateRequest.onerror = (err) => {
-            console.error("Failed to update job status:", err);
+        tryClaimJob(job);
+      };
+      pendingRequest.onerror = () => reject(pendingRequest.error);
+      const tryExpiredLeaseScan = () => {
+        const processingIndex = store.index("queue_status_visible_at");
+        const processingRequest = processingIndex.openCursor(IDBKeyRange.bound([...prefixKeyValues, this.queueName, JobStatus.PROCESSING, ""], [...prefixKeyValues, this.queueName, JobStatus.PROCESSING, "￿"], false, false));
+        processingRequest.onsuccess = (e) => {
+          const cursor = e.target.result;
+          if (!cursor)
+            return;
+          const job = cursor.value;
+          if (job.queue !== this.queueName || job.status !== JobStatus.PROCESSING || !this.matchesPrefixes(job)) {
             cursor.continue();
-          };
-        } catch (err) {
-          console.error("Error updating job:", err);
-          cursor.continue();
-        }
+            return;
+          }
+          if (job.lease_expires_at && job.lease_expires_at >= now) {
+            cursor.continue();
+            return;
+          }
+          tryClaimJob(job);
+        };
+        processingRequest.onerror = () => reject(processingRequest.error);
       };
-      cursorRequest.onerror = () => reject(cursorRequest.error);
       tx.oncomplete = () => {
         if (claimedJob) {
           this.hybridManager?.notifyLocalChange();
@@ -519,7 +599,7 @@ class IndexedDbQueueStorage {
     if (!verifiedJob) {
       return;
     }
-    if (verifiedJob.worker_id !== claimToken) {
+    if (verifiedJob.lease_owner !== claimToken) {
       return;
     }
     if (verifiedJob.status !== JobStatus.PROCESSING) {
@@ -527,6 +607,15 @@ class IndexedDbQueueStorage {
     }
     return verifiedJob;
   }
+  async extendLease(id, workerId, ms) {
+    validateLeaseMs(ms, "ms");
+    const job = await this.get(id);
+    if (!job || job.status !== JobStatus.PROCESSING || job.lease_owner !== workerId) {
+      throw new Error(`extendLease failed: job ${String(id)} is not PROCESSING or lease is not owned by worker ${workerId}`);
+    }
+    job.lease_expires_at = new Date(Date.now() + ms).toISOString();
+    await this.put(job);
+  }
   async size(status = JobStatus.PENDING) {
     const db = await this.getDb();
     const prefixKeyValues = this.getPrefixKeyValues();
@@ -553,10 +642,12 @@ class IndexedDbQueueStorage {
           reject(new Error(`Job ${job.id} not found or does not belong to queue ${this.queueName}`));
           return;
         }
-        const currentAttempts = existing.run_attempts ?? 0;
-        job.run_attempts = currentAttempts + 1;
+        const currentAttempts = existing.attempts ?? 0;
+        job.attempts = currentAttempts + 1;
+        const jobAsRecord = job;
+        jobAsRecord.abort_requested_at = null;
         job.queue = this.queueName;
-        const jobWithPrefixes = job;
+        const jobWithPrefixes = jobAsRecord;
         for (const [key, value] of Object.entries(this.prefixValues)) {
           jobWithPrefixes[key] = value;
         }
@@ -572,23 +663,51 @@ class IndexedDbQueueStorage {
       tx.onerror = () => reject(tx.error);
     });
   }
-  async release(id) {
+  async releaseClaim(id) {
     const job = await this.get(id);
     if (!job)
       return;
     job.status = JobStatus.PENDING;
-    job.worker_id = null;
+    job.lease_owner = null;
     job.progress = 0;
     job.progress_message = "";
     job.progress_details = null;
+    job.abort_requested_at = null;
     await this.put(job);
   }
   async abort(id) {
     const job = await this.get(id);
     if (!job)
       return;
-    job.status = JobStatus.ABORTING;
-    await this.complete(job);
+    const now = new Date().toISOString();
+    if (job.status === JobStatus.PENDING) {
+      job.status = JobStatus.FAILED;
+      job.abort_requested_at = now;
+      job.completed_at = now;
+      await this.put(job);
+    } else if (job.status === JobStatus.PROCESSING) {
+      job.abort_requested_at = now;
+      await this.put(job);
+    }
+  }
+  async saveStatus(id, status) {
+    const db = await this.getDb();
+    const tx = db.transaction(this.tableName, "readwrite");
+    const store = tx.objectStore(this.tableName);
+    const getRequest = store.get(id);
+    return new Promise((resolve, reject) => {
+      getRequest.onsuccess = () => {
+        const record = getRequest.result;
+        if (!record) {
+          resolve();
+          return;
+        }
+        const putRequest = store.put({ ...record, status });
+        putRequest.onsuccess = () => resolve();
+        putRequest.onerror = () => reject(putRequest.error);
+      };
+      getRequest.onerror = () => reject(getRequest.error);
+    });
   }
   async getByRunId(job_run_id) {
     const db = await this.getDb();
@@ -607,6 +726,34 @@ class IndexedDbQueueStorage {
       tx.onerror = () => reject(tx.error);
     });
   }
+  async finalize(id, fields) {
+    const existing = await this.get(id);
+    if (!existing)
+      return;
+    const updated = existing;
+    if ("output" in fields)
+      updated.output = fields.output ?? null;
+    if ("error" in fields)
+      updated.error = fields.error ?? null;
+    if ("error_code" in fields)
+      updated.error_code = fields.error_code ?? null;
+    if ("status" in fields)
+      updated.status = fields.status;
+    if ("completed_at" in fields)
+      updated.completed_at = fields.completed_at ?? null;
+    if ("abort_requested_at" in fields) {
+      updated.abort_requested_at = fields.abort_requested_at ?? null;
+    }
+    if ("lease_owner" in fields)
+      updated.lease_owner = fields.lease_owner ?? null;
+    if ("progress" in fields)
+      updated.progress = fields.progress ?? 0;
+    if ("progress_message" in fields)
+      updated.progress_message = fields.progress_message ?? "";
+    if ("progress_details" in fields)
+      updated.progress_details = fields.progress_details ?? null;
+    await this.put(updated);
+  }
   async deleteAll() {
     const db = await this.getDb();
     const tx = db.transaction(this.tableName, "readwrite");
@@ -888,6 +1035,211 @@ class IndexedDbQueueStorage {
     }
   }
 }
+// src/job-queue/IndexedDbMessageQueue.ts
+class IndexedDbClaim {
+  core;
+  pending;
+  id;
+  body;
+  attempts;
+  workerId;
+  constructor(core, pending, id, body, attempts, workerId) {
+    this.core = core;
+    this.pending = pending;
+    this.id = id;
+    this.body = body;
+    this.attempts = attempts;
+    this.workerId = workerId;
+  }
+  async ack(result) {
+    const buf = this.pending.get(this.id);
+    this.pending.delete(this.id);
+    const current = await this.core.get(this.id) ?? this.body;
+    const output = result !== undefined ? result : buf?.output !== undefined ? buf.output : current.output ?? null;
+    await this.core.finalize(this.id, {
+      output,
+      error: null,
+      error_code: null,
+      status: "COMPLETED",
+      completed_at: current.completed_at ?? new Date().toISOString()
+    });
+  }
+  async retry(opts) {
+    this.pending.delete(this.id);
+    const delay = opts?.delaySeconds ?? 0;
+    const current = await this.core.get(this.id) ?? this.body;
+    await this.core.complete({
+      ...current,
+      status: "PENDING",
+      lease_owner: null,
+      lease_expires_at: null,
+      visible_at: new Date(Date.now() + delay * 1000).toISOString(),
+      progress: 0,
+      progress_message: "",
+      progress_details: null
+    });
+  }
+  async fail(opts) {
+    opts?.permanent;
+    const buf = this.pending.get(this.id);
+    this.pending.delete(this.id);
+    const current = await this.core.get(this.id) ?? this.body;
+    const error = opts?.error !== undefined ? opts.error : buf?.error !== undefined ? buf.error : current.error ?? null;
+    const errorCode = opts?.errorCode !== undefined ? opts.errorCode : buf?.errorCode !== undefined ? buf.errorCode : current.error_code ?? null;
+    const abortRequested = opts?.abortRequested !== undefined ? opts.abortRequested : buf?.abortRequested ?? false;
+    await this.core.finalize(this.id, {
+      error,
+      error_code: errorCode,
+      abort_requested_at: abortRequested ? current.abort_requested_at ?? new Date().toISOString() : current.abort_requested_at ?? null,
+      status: "FAILED",
+      completed_at: current.completed_at ?? new Date().toISOString()
+    });
+  }
+  async extendLease(ms) {
+    await this.core.extendLease(this.id, this.workerId, ms);
+  }
+  async disable() {
+    this.pending.delete(this.id);
+    const current = await this.core.get(this.id);
+    const completedAt = current?.completed_at ?? new Date().toISOString();
+    await this.core.finalize(this.id, {
+      status: "DISABLED",
+      completed_at: completedAt,
+      lease_owner: null,
+      progress: 0,
+      progress_message: "",
+      progress_details: null
+    });
+  }
+}
+
+class IndexedDbMessageQueue {
+  scope = "process";
+  core;
+  pending;
+  constructor(core, pending) {
+    this.core = core;
+    this.pending = pending;
+  }
+  async send(body, opts) {
+    return this.core.add(applySendOptions(body, opts));
+  }
+  async sendBatch(bodies, opts) {
+    const ids = [];
+    for (const body of bodies) {
+      ids.push(await this.send(body, opts));
+    }
+    return ids;
+  }
+  async receive(opts) {
+    const max = Math.max(1, opts.max ?? 1);
+    const claims = [];
+    while (claims.length < max) {
+      const job = await this.core.next(opts.workerId, { leaseMs: opts.leaseMs });
+      if (!job)
+        break;
+      claims.push(new IndexedDbClaim(this.core, this.pending, job.id, job, job.attempts ?? 0, opts.workerId));
+    }
+    return claims;
+  }
+  async releaseClaim(id) {
+    this.pending.delete(id);
+    await this.core.releaseClaim(id);
+  }
+  async migrate() {
+    await this.core.migrate();
+  }
+  getMigrations() {
+    return this.core.getMigrations();
+  }
+  subscribeToChanges(callback, options) {
+    return this.core.subscribeToChanges(callback, options);
+  }
+}
+function applySendOptions(body, opts) {
+  if (!opts)
+    return body;
+  const out = { ...body };
+  if (opts.delaySeconds != null) {
+    out.visible_at = new Date(Date.now() + opts.delaySeconds * 1000).toISOString();
+  }
+  if (opts.timeoutSeconds != null) {
+    out.deadline_at = new Date(Date.now() + opts.timeoutSeconds * 1000).toISOString();
+  }
+  if (opts.fingerprint != null)
+    out.fingerprint = opts.fingerprint;
+  if (opts.jobRunId != null)
+    out.job_run_id = opts.jobRunId;
+  if (opts.maxAttempts != null)
+    out.max_attempts = opts.maxAttempts;
+  return out;
+}
+// src/job-queue/IndexedDbJobStore.ts
+class IndexedDbJobStore {
+  core;
+  pending;
+  constructor(core, pending) {
+    this.core = core;
+    this.pending = pending;
+  }
+  get(id) {
+    return this.core.get(id);
+  }
+  async peek(status, num) {
+    return this.core.peek(status, num);
+  }
+  size(status) {
+    return this.core.size(status);
+  }
+  async getByRunId(runId) {
+    return this.core.getByRunId(runId);
+  }
+  outputForInput(input) {
+    return this.core.outputForInput(input);
+  }
+  async saveProgress(id, progress, message, details) {
+    await this.core.saveProgress(id, progress, message, details);
+  }
+  async saveResult(id, output) {
+    const buf = this.pending.get(id) ?? {};
+    buf.output = output ?? null;
+    this.pending.set(id, buf);
+  }
+  async saveError(id, error, errorCode, abortRequested) {
+    const buf = this.pending.get(id) ?? {};
+    buf.error = error;
+    buf.errorCode = errorCode;
+    buf.abortRequested = abortRequested;
+    this.pending.set(id, buf);
+  }
+  async deleteByStatusAndAge(status, olderThanMs) {
+    await this.core.deleteJobsByStatusAndAge(status, olderThanMs);
+  }
+  async delete(id) {
+    this.pending.delete(id);
+    await this.core.delete(id);
+  }
+  async deleteAll() {
+    this.pending.clear();
+    await this.core.deleteAll();
+  }
+  async abort(id) {
+    await this.core.abort(id);
+  }
+  async saveStatus(id, status) {
+    await this.core.saveStatus(id, status);
+  }
+}
+// src/job-queue/createIndexedDbQueue.ts
+function createIndexedDbQueue(queueName, opts) {
+  const core = new IndexedDbQueueStorage(queueName, opts);
+  const pending = new Map;
+  return {
+    messageQueue: new IndexedDbMessageQueue(core, pending),
+    jobStore: new IndexedDbJobStore(core, pending),
+    core
+  };
+}
 // src/job-queue/IndexedDbRateLimiterStorage.ts
 import { createServiceToken as createServiceToken2 } from "@workglow/util";
 
@@ -1232,12 +1584,15 @@ export {
   indexedDbRateLimiterExecutionMigrations,
   indexedDbQueueMigrations,
   indexedDbQueueMigrationGroup,
+  createIndexedDbQueue,
   MigrationAbortedByOtherTabError,
   IndexedDbRateLimiterStorage,
   IndexedDbQueueStorage,
   IndexedDbMigrationRunner,
+  IndexedDbMessageQueue,
+  IndexedDbJobStore,
   INDEXED_DB_RATE_LIMITER_STORAGE,
   INDEXED_DB_QUEUE_STORAGE
 };
 
-//# debugId=B97875F22F699F3164756E2164756E21
+//# debugId=DD150AE4B3AEA97B64756E2164756E21