@workglow/indexeddb 0.2.28

package/dist/job-queue/node.js

@@ -0,0 +1,1195 @@
+// src/job-queue/IndexedDbQueueStorage.ts
+import { createServiceToken, deepEqual as deepEqual2, makeFingerprint, uuid4 } from "@workglow/util";
+import { HybridSubscriptionManager } from "@workglow/storage";
+
+// src/storage/IndexedDbTable.ts
+import { deepEqual } from "@workglow/util";
+var METADATA_STORE_NAME = "__schema_metadata__";
+async function saveSchemaMetadata(db, tableName, snapshot) {
+  return new Promise((resolve, reject) => {
+    try {
+      const transaction = db.transaction(METADATA_STORE_NAME, "readwrite");
+      const store = transaction.objectStore(METADATA_STORE_NAME);
+      const request = store.put({ ...snapshot, tableName }, tableName);
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+      transaction.onerror = () => reject(transaction.error);
+    } catch (err) {
+      resolve();
+    }
+  });
+}
+async function openIndexedDbTable(tableName, version, upgradeNeededCallback) {
+  return new Promise((resolve, reject) => {
+    const openRequest = indexedDB.open(tableName, version);
+    openRequest.onsuccess = (event) => {
+      const db = event.target.result;
+      db.onversionchange = () => {
+        db.close();
+      };
+      resolve(db);
+    };
+    openRequest.onupgradeneeded = (event) => {
+      if (upgradeNeededCallback) {
+        upgradeNeededCallback(event);
+      }
+    };
+    openRequest.onerror = () => {
+      const error = openRequest.error;
+      if (error && error.name === "VersionError") {
+        reject(new Error(`Database ${tableName} exists at a higher version. Cannot open at version ${version || "current"}.`));
+      } else {
+        reject(error);
+      }
+    };
+    openRequest.onblocked = () => {
+      reject(new Error(`Database ${tableName} is blocked. Close all other tabs using this database.`));
+    };
+  });
+}
+async function deleteIndexedDbTable(tableName) {
+  return new Promise((resolve, reject) => {
+    const deleteRequest = indexedDB.deleteDatabase(tableName);
+    deleteRequest.onsuccess = () => resolve();
+    deleteRequest.onerror = () => reject(deleteRequest.error);
+    deleteRequest.onblocked = () => {
+      reject(new Error(`Cannot delete database ${tableName}. Close all other tabs using this database.`));
+    };
+  });
+}
+function compareSchemas(store, expectedPrimaryKey, expectedIndexes) {
+  const diff = {
+    indexesToAdd: [],
+    indexesToRemove: [],
+    indexesToModify: [],
+    primaryKeyChanged: false,
+    needsObjectStoreRecreation: false
+  };
+  const actualKeyPath = store.keyPath;
+  const normalizedExpected = Array.isArray(expectedPrimaryKey) ? expectedPrimaryKey : expectedPrimaryKey;
+  const normalizedActual = Array.isArray(actualKeyPath) ? actualKeyPath : actualKeyPath;
+  if (!deepEqual(normalizedExpected, normalizedActual)) {
+    diff.primaryKeyChanged = true;
+    diff.needsObjectStoreRecreation = true;
+    return diff;
+  }
+  const existingIndexes = new Map;
+  for (let i = 0;i < store.indexNames.length; i++) {
+    const indexName = store.indexNames[i];
+    existingIndexes.set(indexName, store.index(indexName));
+  }
+  for (const expectedIdx of expectedIndexes) {
+    const existingIdx = existingIndexes.get(expectedIdx.name);
+    if (!existingIdx) {
+      diff.indexesToAdd.push(expectedIdx);
+    } else {
+      const expectedKeyPath = Array.isArray(expectedIdx.keyPath) ? expectedIdx.keyPath : [expectedIdx.keyPath];
+      const actualKeyPath2 = Array.isArray(existingIdx.keyPath) ? existingIdx.keyPath : [existingIdx.keyPath];
+      const keyPathChanged = !deepEqual(expectedKeyPath, actualKeyPath2);
+      const uniqueChanged = existingIdx.unique !== (expectedIdx.options?.unique ?? false);
+      const multiEntryChanged = existingIdx.multiEntry !== (expectedIdx.options?.multiEntry ?? false);
+      if (keyPathChanged || uniqueChanged || multiEntryChanged) {
+        diff.indexesToModify.push(expectedIdx);
+      }
+      existingIndexes.delete(expectedIdx.name);
+    }
+  }
+  diff.indexesToRemove = Array.from(existingIndexes.keys());
+  return diff;
+}
+async function readAllData(store) {
+  return new Promise((resolve, reject) => {
+    const request = store.getAll();
+    request.onsuccess = () => resolve(request.result || []);
+    request.onerror = () => reject(request.error);
+  });
+}
+async function performIncrementalMigration(db, tableName, diff, options = {}) {
+  const currentVersion = db.version;
+  const newVersion = currentVersion + 1;
+  db.close();
+  options.onMigrationProgress?.(`Migrating ${tableName} from version ${currentVersion} to ${newVersion}...`, 0);
+  return openIndexedDbTable(tableName, newVersion, (event) => {
+    const transaction = event.target.transaction;
+    const store = transaction.objectStore(tableName);
+    for (const indexName of diff.indexesToRemove) {
+      options.onMigrationProgress?.(`Removing index: ${indexName}`, 0.2);
+      store.deleteIndex(indexName);
+    }
+    for (const indexDef of diff.indexesToModify) {
+      options.onMigrationProgress?.(`Updating index: ${indexDef.name}`, 0.4);
+      if (store.indexNames.contains(indexDef.name)) {
+        store.deleteIndex(indexDef.name);
+      }
+      store.createIndex(indexDef.name, indexDef.keyPath, indexDef.options);
+    }
+    for (const indexDef of diff.indexesToAdd) {
+      options.onMigrationProgress?.(`Adding index: ${indexDef.name}`, 0.6);
+      store.createIndex(indexDef.name, indexDef.keyPath, indexDef.options);
+    }
+    options.onMigrationProgress?.(`Migration complete`, 1);
+  });
+}
+async function performDestructiveMigration(db, tableName, primaryKey, expectedIndexes, options = {}, autoIncrement = false) {
+  if (!options.allowDestructiveMigration) {
+    throw new Error(`Destructive migration required for ${tableName} but not allowed. ` + `Primary key has changed. Set allowDestructiveMigration=true to proceed with data loss, ` + `or provide a dataTransformer to migrate data.`);
+  }
+  const currentVersion = db.version;
+  const newVersion = currentVersion + 1;
+  options.onMigrationProgress?.(`Performing destructive migration of ${tableName}. Reading existing data...`, 0);
+  let existingData = [];
+  try {
+    const transaction = db.transaction(tableName, "readonly");
+    const store = transaction.objectStore(tableName);
+    existingData = await readAllData(store);
+    options.onMigrationProgress?.(`Read ${existingData.length} records`, 0.3);
+  } catch (err) {
+    options.onMigrationWarning?.(`Failed to read existing data during migration: ${err}`, err);
+  }
+  db.close();
+  if (options.dataTransformer && existingData.length > 0) {
+    options.onMigrationProgress?.(`Transforming ${existingData.length} records...`, 0.4);
+    try {
+      const transformed = [];
+      for (let i = 0;i < existingData.length; i++) {
+        const record = existingData[i];
+        const transformedRecord = await options.dataTransformer(record);
+        if (transformedRecord !== undefined && transformedRecord !== null) {
+          transformed.push(transformedRecord);
+        }
+        if (i % 100 === 0) {
+          options.onMigrationProgress?.(`Transformed ${i}/${existingData.length} records`, 0.4 + i / existingData.length * 0.3);
+        }
+      }
+      existingData = transformed;
+      options.onMigrationProgress?.(`Transformation complete: ${existingData.length} records`, 0.7);
+    } catch (err) {
+      options.onMigrationWarning?.(`Data transformation failed: ${err}. Some data may be lost.`, err);
+      existingData = [];
+    }
+  }
+  options.onMigrationProgress?.(`Recreating object store...`, 0.75);
+  const newDb = await openIndexedDbTable(tableName, newVersion, (event) => {
+    const db2 = event.target.result;
+    if (db2.objectStoreNames.contains(tableName)) {
+      db2.deleteObjectStore(tableName);
+    }
+    const store = db2.createObjectStore(tableName, { keyPath: primaryKey, autoIncrement });
+    for (const idx of expectedIndexes) {
+      store.createIndex(idx.name, idx.keyPath, idx.options);
+    }
+    if (existingData.length > 0) {
+      options.onMigrationProgress?.(`Restoring ${existingData.length} records...`, 0.8);
+      for (const record of existingData) {
+        try {
+          store.put(record);
+        } catch (err) {
+          options.onMigrationWarning?.(`Failed to restore record: ${err}`, err);
+        }
+      }
+    }
+  });
+  options.onMigrationProgress?.(`Destructive migration complete`, 1);
+  return newDb;
+}
+async function createNewDatabase(tableName, primaryKey, expectedIndexes, options = {}, autoIncrement = false) {
+  options.onMigrationProgress?.(`Creating new database: ${tableName}`, 0);
+  try {
+    await deleteIndexedDbTable(tableName);
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  } catch (err) {}
+  const version = 1;
+  const db = await openIndexedDbTable(tableName, version, (event) => {
+    const db2 = event.target.result;
+    if (!db2.objectStoreNames.contains(METADATA_STORE_NAME)) {
+      db2.createObjectStore(METADATA_STORE_NAME, { keyPath: "tableName" });
+    }
+    const store = db2.createObjectStore(tableName, { keyPath: primaryKey, autoIncrement });
+    for (const idx of expectedIndexes) {
+      store.createIndex(idx.name, idx.keyPath, idx.options);
+    }
+  });
+  const snapshot = {
+    version: db.version,
+    primaryKey,
+    indexes: expectedIndexes,
+    recordCount: 0,
+    timestamp: Date.now()
+  };
+  await saveSchemaMetadata(db, tableName, snapshot);
+  options.onMigrationProgress?.(`Database created successfully`, 1);
+  return db;
+}
+async function ensureIndexedDbTable(tableName, primaryKey, expectedIndexes = [], options = {}, autoIncrement = false) {
+  try {
+    let db;
+    let wasJustCreated = false;
+    try {
+      db = await openIndexedDbTable(tableName);
+      if (db.version === 1 && !db.objectStoreNames.contains(tableName)) {
+        wasJustCreated = true;
+        db.close();
+      }
+    } catch (err) {
+      options.onMigrationProgress?.(`Database ${tableName} does not exist or has version conflict, creating...`, 0);
+      return await createNewDatabase(tableName, primaryKey, expectedIndexes, options, autoIncrement);
+    }
+    if (wasJustCreated) {
+      options.onMigrationProgress?.(`Creating new database: ${tableName}`, 0);
+      try {
+        await deleteIndexedDbTable(tableName);
+        await new Promise((resolve) => setTimeout(resolve, 50));
+      } catch (err) {}
+      db = await openIndexedDbTable(tableName, 1, (event) => {
+        const db2 = event.target.result;
+        if (!db2.objectStoreNames.contains(METADATA_STORE_NAME)) {
+          db2.createObjectStore(METADATA_STORE_NAME, { keyPath: "tableName" });
+        }
+        const store2 = db2.createObjectStore(tableName, { keyPath: primaryKey, autoIncrement });
+        for (const idx of expectedIndexes) {
+          store2.createIndex(idx.name, idx.keyPath, idx.options);
+        }
+      });
+      const snapshot2 = {
+        version: db.version,
+        primaryKey,
+        indexes: expectedIndexes,
+        recordCount: 0,
+        timestamp: Date.now()
+      };
+      await saveSchemaMetadata(db, tableName, snapshot2);
+      options.onMigrationProgress?.(`Database created successfully`, 1);
+      return db;
+    }
+    if (!db.objectStoreNames.contains(METADATA_STORE_NAME)) {
+      const currentVersion = db.version;
+      db.close();
+      db = await openIndexedDbTable(tableName, currentVersion + 1, (event) => {
+        const db2 = event.target.result;
+        if (!db2.objectStoreNames.contains(METADATA_STORE_NAME)) {
+          db2.createObjectStore(METADATA_STORE_NAME, { keyPath: "tableName" });
+        }
+      });
+    }
+    if (!db.objectStoreNames.contains(tableName)) {
+      options.onMigrationProgress?.(`Object store ${tableName} does not exist, creating...`, 0);
+      db.close();
+      return await createNewDatabase(tableName, primaryKey, expectedIndexes, options, autoIncrement);
+    }
+    const transaction = db.transaction(tableName, "readonly");
+    const store = transaction.objectStore(tableName);
+    const diff = compareSchemas(store, primaryKey, expectedIndexes);
+    await new Promise((resolve) => {
+      transaction.oncomplete = () => resolve();
+      transaction.onerror = () => resolve();
+    });
+    const needsMigration = diff.indexesToAdd.length > 0 || diff.indexesToRemove.length > 0 || diff.indexesToModify.length > 0 || diff.needsObjectStoreRecreation;
+    if (!needsMigration) {
+      options.onMigrationProgress?.(`Schema for ${tableName} is up to date`, 1);
+      const snapshot2 = {
+        version: db.version,
+        primaryKey,
+        indexes: expectedIndexes,
+        timestamp: Date.now()
+      };
+      await saveSchemaMetadata(db, tableName, snapshot2);
+      return db;
+    }
+    if (diff.needsObjectStoreRecreation) {
+      options.onMigrationProgress?.(`Schema change requires object store recreation for ${tableName}`, 0);
+      db = await performDestructiveMigration(db, tableName, primaryKey, expectedIndexes, options, autoIncrement);
+    } else {
+      options.onMigrationProgress?.(`Performing incremental migration for ${tableName}`, 0);
+      db = await performIncrementalMigration(db, tableName, diff, options);
+    }
+    const snapshot = {
+      version: db.version,
+      primaryKey,
+      indexes: expectedIndexes,
+      timestamp: Date.now()
+    };
+    await saveSchemaMetadata(db, tableName, snapshot);
+    return db;
+  } catch (err) {
+    options.onMigrationWarning?.(`Migration failed for ${tableName}: ${err}`, err);
+    throw err;
+  }
+}
+
+// src/job-queue/IndexedDbQueueStorage.ts
+import { JobStatus } from "@workglow/job-queue";
+var INDEXED_DB_QUEUE_STORAGE = createServiceToken("jobqueue.storage.indexedDb");
+
+class IndexedDbQueueStorage {
+  queueName;
+  scope = "process";
+  db;
+  tableName;
+  migrationOptions;
+  prefixes;
+  prefixValues;
+  hybridManager = null;
+  hybridOptions;
+  constructor(queueName, options = {}) {
+    this.queueName = queueName;
+    this.migrationOptions = options;
+    this.prefixes = options.prefixes ?? [];
+    this.prefixValues = options.prefixValues ?? {};
+    this.hybridOptions = {
+      useBroadcastChannel: options.useBroadcastChannel ?? true,
+      backupPollingIntervalMs: options.backupPollingIntervalMs ?? 5000
+    };
+    if (this.prefixes.length > 0) {
+      const prefixNames = this.prefixes.map((p) => p.name).join("_");
+      this.tableName = `jobs_${prefixNames}`;
+    } else {
+      this.tableName = "jobs";
+    }
+  }
+  getPrefixColumnNames() {
+    return this.prefixes.map((p) => p.name);
+  }
+  matchesPrefixes(job) {
+    for (const [key, value] of Object.entries(this.prefixValues)) {
+      if (job[key] !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
+  getPrefixKeyValues() {
+    return this.prefixes.map((p) => this.prefixValues[p.name]);
+  }
+  async getDb() {
+    if (this.db)
+      return this.db;
+    await this.setupDatabase();
+    return this.db;
+  }
+  async setupDatabase() {
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const buildKeyPath = (basePath) => {
+      return [...prefixColumnNames, ...basePath];
+    };
+    const expectedIndexes = [
+      {
+        name: "queue_status",
+        keyPath: buildKeyPath(["queue", "status"]),
+        options: { unique: false }
+      },
+      {
+        name: "queue_status_run_after",
+        keyPath: buildKeyPath(["queue", "status", "run_after"]),
+        options: { unique: false }
+      },
+      {
+        name: "queue_job_run_id",
+        keyPath: buildKeyPath(["queue", "job_run_id"]),
+        options: { unique: false }
+      },
+      {
+        name: "queue_fingerprint_status",
+        keyPath: buildKeyPath(["queue", "fingerprint", "status"]),
+        options: { unique: false }
+      }
+    ];
+    this.db = await ensureIndexedDbTable(this.tableName, "id", expectedIndexes, this.migrationOptions);
+  }
+  async add(job) {
+    const db = await this.getDb();
+    const now = new Date().toISOString();
+    const jobWithPrefixes = job;
+    jobWithPrefixes.id = jobWithPrefixes.id ?? uuid4();
+    jobWithPrefixes.job_run_id = jobWithPrefixes.job_run_id ?? uuid4();
+    jobWithPrefixes.queue = this.queueName;
+    jobWithPrefixes.fingerprint = await makeFingerprint(jobWithPrefixes.input);
+    jobWithPrefixes.status = JobStatus.PENDING;
+    jobWithPrefixes.progress = 0;
+    jobWithPrefixes.progress_message = "";
+    jobWithPrefixes.progress_details = null;
+    jobWithPrefixes.created_at = now;
+    jobWithPrefixes.run_after = now;
+    for (const [key, value] of Object.entries(this.prefixValues)) {
+      jobWithPrefixes[key] = value;
+    }
+    const tx = db.transaction(this.tableName, "readwrite");
+    const store = tx.objectStore(this.tableName);
+    return new Promise((resolve, reject) => {
+      const request = store.add(jobWithPrefixes);
+      tx.oncomplete = () => {
+        this.hybridManager?.notifyLocalChange();
+        resolve(jobWithPrefixes.id);
+      };
+      tx.onerror = () => reject(tx.error);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async get(id) {
+    const db = await this.getDb();
+    const tx = db.transaction(this.tableName, "readonly");
+    const store = tx.objectStore(this.tableName);
+    const request = store.get(id);
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => {
+        const job = request.result;
+        if (job && job.queue === this.queueName && this.matchesPrefixes(job)) {
+          resolve(job);
+        } else {
+          resolve(undefined);
+        }
+      };
+      request.onerror = () => reject(request.error);
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async peek(status = JobStatus.PENDING, num = 100) {
+    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 prefixKeyValues = this.getPrefixKeyValues();
+    return new Promise((resolve, reject) => {
+      const ret = new Map;
+      const keyRange = IDBKeyRange.bound([...prefixKeyValues, this.queueName, status, ""], [...prefixKeyValues, this.queueName, status, "￿"]);
+      const cursorRequest = index.openCursor(keyRange);
+      const handleCursor = (e) => {
+        const cursor = e.target.result;
+        if (!cursor || ret.size >= num) {
+          resolve(Array.from(ret.values()));
+          return;
+        }
+        const job = cursor.value;
+        if (this.matchesPrefixes(job)) {
+          ret.set(cursor.value.id, cursor.value);
+        }
+        cursor.continue();
+      };
+      cursorRequest.onsuccess = handleCursor;
+      cursorRequest.onerror = () => reject(cursorRequest.error);
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async next(workerId) {
+    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 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 cursor = e.target.result;
+        if (!cursor) {
+          return;
+        }
+        if (cursorStopped) {
+          return;
+        }
+        const job = cursor.value;
+        if (job.queue !== this.queueName || job.status !== JobStatus.PENDING || !this.matchesPrefixes(job)) {
+          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);
+            cursor.continue();
+          };
+        } catch (err) {
+          console.error("Error updating job:", err);
+          cursor.continue();
+        }
+      };
+      cursorRequest.onerror = () => reject(cursorRequest.error);
+      tx.oncomplete = () => {
+        if (claimedJob) {
+          this.hybridManager?.notifyLocalChange();
+        }
+        resolve(claimedJob);
+      };
+      tx.onerror = () => reject(tx.error);
+    });
+    if (!jobToReturn) {
+      return;
+    }
+    const verifiedJob = await this.get(jobToReturn.id);
+    if (!verifiedJob) {
+      return;
+    }
+    if (verifiedJob.worker_id !== claimToken) {
+      return;
+    }
+    if (verifiedJob.status !== JobStatus.PROCESSING) {
+      return;
+    }
+    return verifiedJob;
+  }
+  async size(status = JobStatus.PENDING) {
+    const db = await this.getDb();
+    const prefixKeyValues = this.getPrefixKeyValues();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.tableName, "readonly");
+      const store = tx.objectStore(this.tableName);
+      const index = store.index("queue_status");
+      const keyRange = IDBKeyRange.only([...prefixKeyValues, this.queueName, status]);
+      const request = index.count(keyRange);
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async complete(job) {
+    const db = await this.getDb();
+    const tx = db.transaction(this.tableName, "readwrite");
+    const store = tx.objectStore(this.tableName);
+    return new Promise((resolve, reject) => {
+      const getReq = store.get(job.id);
+      getReq.onsuccess = () => {
+        const existing = getReq.result;
+        if (!existing || existing.queue !== this.queueName || !this.matchesPrefixes(existing)) {
+          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;
+        job.queue = this.queueName;
+        const jobWithPrefixes = job;
+        for (const [key, value] of Object.entries(this.prefixValues)) {
+          jobWithPrefixes[key] = value;
+        }
+        const putReq = store.put(jobWithPrefixes);
+        putReq.onsuccess = () => {};
+        putReq.onerror = () => reject(putReq.error);
+      };
+      getReq.onerror = () => reject(getReq.error);
+      tx.oncomplete = () => {
+        this.hybridManager?.notifyLocalChange();
+        resolve();
+      };
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async release(id) {
+    const job = await this.get(id);
+    if (!job)
+      return;
+    job.status = JobStatus.PENDING;
+    job.worker_id = null;
+    job.progress = 0;
+    job.progress_message = "";
+    job.progress_details = 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);
+  }
+  async getByRunId(job_run_id) {
+    const db = await this.getDb();
+    const tx = db.transaction(this.tableName, "readonly");
+    const store = tx.objectStore(this.tableName);
+    const index = store.index("queue_job_run_id");
+    const prefixKeyValues = this.getPrefixKeyValues();
+    const keyRange = IDBKeyRange.only([...prefixKeyValues, this.queueName, job_run_id]);
+    const request = index.getAll(keyRange);
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => {
+        const results = (request.result || []).filter((job) => this.matchesPrefixes(job));
+        resolve(results);
+      };
+      request.onerror = () => reject(request.error);
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async deleteAll() {
+    const db = await this.getDb();
+    const tx = db.transaction(this.tableName, "readwrite");
+    const store = tx.objectStore(this.tableName);
+    const index = store.index("queue_status");
+    const prefixKeyValues = this.getPrefixKeyValues();
+    return new Promise((resolve, reject) => {
+      const keyRange = IDBKeyRange.bound([...prefixKeyValues, this.queueName, ""], [...prefixKeyValues, this.queueName, "￿"]);
+      const request = index.openCursor(keyRange);
+      request.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          const job = cursor.value;
+          if (job.queue === this.queueName && this.matchesPrefixes(job)) {
+            const deleteRequest = cursor.delete();
+            deleteRequest.onsuccess = () => {
+              cursor.continue();
+            };
+            deleteRequest.onerror = () => {
+              cursor.continue();
+            };
+          } else {
+            cursor.continue();
+          }
+        }
+      };
+      tx.oncomplete = () => {
+        this.hybridManager?.notifyLocalChange();
+        resolve();
+      };
+      tx.onerror = () => reject(tx.error);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async outputForInput(input) {
+    const fingerprint = await makeFingerprint(input);
+    const db = await this.getDb();
+    const tx = db.transaction(this.tableName, "readonly");
+    const store = tx.objectStore(this.tableName);
+    const index = store.index("queue_fingerprint_status");
+    const prefixKeyValues = this.getPrefixKeyValues();
+    const request = index.get([
+      ...prefixKeyValues,
+      this.queueName,
+      fingerprint,
+      JobStatus.COMPLETED
+    ]);
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => {
+        const job = request.result;
+        if (job && this.matchesPrefixes(job)) {
+          resolve(job.output ?? null);
+        } else {
+          resolve(null);
+        }
+      };
+      request.onerror = () => reject(request.error);
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async saveProgress(id, progress, message, details) {
+    const job = await this.get(id);
+    if (!job)
+      throw new Error(`Job ${id} not found`);
+    job.progress = progress;
+    job.progress_message = message;
+    job.progress_details = details;
+    await this.put(job);
+  }
+  async put(job) {
+    const db = await this.getDb();
+    const tx = db.transaction(this.tableName, "readwrite");
+    const store = tx.objectStore(this.tableName);
+    job.queue = this.queueName;
+    const jobWithPrefixes = job;
+    for (const [key, value] of Object.entries(this.prefixValues)) {
+      jobWithPrefixes[key] = value;
+    }
+    return new Promise((resolve, reject) => {
+      const putReq = store.put(jobWithPrefixes);
+      putReq.onerror = () => reject(putReq.error);
+      tx.oncomplete = () => {
+        this.hybridManager?.notifyLocalChange();
+        resolve();
+      };
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async delete(id) {
+    const job = await this.get(id);
+    if (!job)
+      return;
+    const db = await this.getDb();
+    const tx = db.transaction(this.tableName, "readwrite");
+    const store = tx.objectStore(this.tableName);
+    const request = store.delete(id);
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+      tx.oncomplete = () => {
+        this.hybridManager?.notifyLocalChange();
+      };
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async deleteJobsByStatusAndAge(status, olderThanMs) {
+    const db = await this.getDb();
+    const tx = db.transaction(this.tableName, "readwrite");
+    const store = tx.objectStore(this.tableName);
+    const index = store.index("queue_status");
+    const cutoffDate = new Date(Date.now() - olderThanMs).toISOString();
+    const prefixKeyValues = this.getPrefixKeyValues();
+    const keyRange = IDBKeyRange.only([...prefixKeyValues, this.queueName, status]);
+    return new Promise((resolve, reject) => {
+      const request = index.openCursor(keyRange);
+      request.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          const job = cursor.value;
+          if (job.queue === this.queueName && this.matchesPrefixes(job) && job.status === status && job.completed_at && job.completed_at <= cutoffDate) {
+            cursor.delete();
+          }
+          cursor.continue();
+        }
+      };
+      tx.oncomplete = () => {
+        this.hybridManager?.notifyLocalChange();
+        resolve();
+      };
+      tx.onerror = () => reject(tx.error);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async getAllJobs() {
+    const db = await this.getDb();
+    const tx = db.transaction(this.tableName, "readonly");
+    const store = tx.objectStore(this.tableName);
+    const index = store.index("queue_status");
+    const prefixKeyValues = this.getPrefixKeyValues();
+    return new Promise((resolve, reject) => {
+      const jobs = [];
+      const keyRange = IDBKeyRange.bound([...prefixKeyValues, this.queueName, ""], [...prefixKeyValues, this.queueName, "￿"]);
+      const request = index.openCursor(keyRange);
+      request.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          const job = cursor.value;
+          if (job.queue === this.queueName && this.matchesPrefixes(job)) {
+            jobs.push(job);
+          }
+          cursor.continue();
+        }
+      };
+      tx.oncomplete = () => resolve(jobs);
+      tx.onerror = () => reject(tx.error);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async getAllJobsWithFilter(prefixFilter) {
+    const db = await this.getDb();
+    const tx = db.transaction(this.tableName, "readonly");
+    const store = tx.objectStore(this.tableName);
+    return new Promise((resolve, reject) => {
+      const jobs = [];
+      const request = store.openCursor();
+      request.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          const job = cursor.value;
+          if (job.queue !== this.queueName) {
+            cursor.continue();
+            return;
+          }
+          if (Object.keys(prefixFilter).length === 0) {
+            jobs.push(job);
+          } else {
+            let matches = true;
+            for (const [key, value] of Object.entries(prefixFilter)) {
+              if (job[key] !== value) {
+                matches = false;
+                break;
+              }
+            }
+            if (matches) {
+              jobs.push(job);
+            }
+          }
+          cursor.continue();
+        }
+      };
+      tx.oncomplete = () => resolve(jobs);
+      tx.onerror = () => reject(tx.error);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  isCustomPrefixFilter(prefixFilter) {
+    if (prefixFilter === undefined) {
+      return false;
+    }
+    if (Object.keys(prefixFilter).length === 0) {
+      return true;
+    }
+    const instanceKeys = Object.keys(this.prefixValues);
+    const filterKeys = Object.keys(prefixFilter);
+    if (instanceKeys.length !== filterKeys.length) {
+      return true;
+    }
+    for (const key of instanceKeys) {
+      if (this.prefixValues[key] !== prefixFilter[key]) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getHybridManager() {
+    if (!this.hybridManager) {
+      const channelName = `indexeddb-queue-${this.tableName}-${this.queueName}`;
+      this.hybridManager = new HybridSubscriptionManager(channelName, async () => {
+        const jobs = await this.getAllJobs();
+        return new Map(jobs.map((j) => [j.id, j]));
+      }, (a, b) => deepEqual2(a, b), {
+        insert: (item) => ({ type: "INSERT", new: item }),
+        update: (oldItem, newItem) => ({ type: "UPDATE", old: oldItem, new: newItem }),
+        delete: (item) => ({ type: "DELETE", old: item })
+      }, {
+        defaultIntervalMs: 1000,
+        useBroadcastChannel: this.hybridOptions.useBroadcastChannel,
+        backupPollingIntervalMs: this.hybridOptions.backupPollingIntervalMs
+      });
+    }
+    return this.hybridManager;
+  }
+  subscribeWithCustomPrefixFilter(callback, prefixFilter, intervalMs) {
+    let lastKnownJobs = new Map;
+    let cancelled = false;
+    const poll = async () => {
+      if (cancelled)
+        return;
+      try {
+        const currentJobs = await this.getAllJobsWithFilter(prefixFilter);
+        if (cancelled)
+          return;
+        const currentMap = new Map(currentJobs.map((j) => [j.id, j]));
+        for (const [id, job] of currentMap) {
+          const old = lastKnownJobs.get(id);
+          if (!old) {
+            callback({ type: "INSERT", new: job });
+          } else if (!deepEqual2(old, job)) {
+            callback({ type: "UPDATE", old, new: job });
+          }
+        }
+        for (const [id, job] of lastKnownJobs) {
+          if (!currentMap.has(id)) {
+            callback({ type: "DELETE", old: job });
+          }
+        }
+        lastKnownJobs = currentMap;
+      } catch {}
+    };
+    const intervalId = setInterval(poll, intervalMs);
+    poll();
+    return () => {
+      cancelled = true;
+      clearInterval(intervalId);
+    };
+  }
+  subscribeToChanges(callback, options) {
+    const intervalMs = options?.pollingIntervalMs ?? 1000;
+    if (this.isCustomPrefixFilter(options?.prefixFilter)) {
+      return this.subscribeWithCustomPrefixFilter(callback, options.prefixFilter, intervalMs);
+    }
+    const manager = this.getHybridManager();
+    return manager.subscribe(callback, { intervalMs });
+  }
+  destroy() {
+    if (this.hybridManager) {
+      this.hybridManager.destroy();
+      this.hybridManager = null;
+    }
+  }
+}
+// src/job-queue/IndexedDbRateLimiterStorage.ts
+import { createServiceToken as createServiceToken2 } from "@workglow/util";
+var INDEXED_DB_RATE_LIMITER_STORAGE = createServiceToken2("ratelimiter.storage.indexedDb");
+
+class IndexedDbRateLimiterStorage {
+  scope = "process";
+  executionDb;
+  nextAvailableDb;
+  executionTableName;
+  nextAvailableTableName;
+  migrationOptions;
+  prefixes;
+  prefixValues;
+  constructor(options = {}) {
+    this.migrationOptions = options;
+    this.prefixes = options.prefixes ?? [];
+    this.prefixValues = options.prefixValues ?? {};
+    if (this.prefixes.length > 0) {
+      const prefixNames = this.prefixes.map((p) => p.name).join("_");
+      this.executionTableName = `rate_limit_executions_${prefixNames}`;
+      this.nextAvailableTableName = `rate_limit_next_available_${prefixNames}`;
+    } else {
+      this.executionTableName = "rate_limit_executions";
+      this.nextAvailableTableName = "rate_limit_next_available";
+    }
+  }
+  getPrefixColumnNames() {
+    return this.prefixes.map((p) => p.name);
+  }
+  matchesPrefixes(record) {
+    for (const [key, value] of Object.entries(this.prefixValues)) {
+      if (record[key] !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
+  getPrefixKeyValues() {
+    return this.prefixes.map((p) => this.prefixValues[p.name]);
+  }
+  async getExecutionDb() {
+    if (this.executionDb)
+      return this.executionDb;
+    await this.setupDatabase();
+    return this.executionDb;
+  }
+  async getNextAvailableDb() {
+    if (this.nextAvailableDb)
+      return this.nextAvailableDb;
+    await this.setupDatabase();
+    return this.nextAvailableDb;
+  }
+  async setupDatabase() {
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const buildKeyPath = (basePath) => {
+      return [...prefixColumnNames, ...basePath];
+    };
+    const executionIndexes = [
+      {
+        name: "queue_executed_at",
+        keyPath: buildKeyPath(["queue_name", "executed_at"]),
+        options: { unique: false }
+      }
+    ];
+    this.executionDb = await ensureIndexedDbTable(this.executionTableName, "id", executionIndexes, this.migrationOptions);
+    const nextAvailableIndexes = [
+      {
+        name: "queue_name",
+        keyPath: buildKeyPath(["queue_name"]),
+        options: { unique: true }
+      }
+    ];
+    this.nextAvailableDb = await ensureIndexedDbTable(this.nextAvailableTableName, buildKeyPath(["queue_name"]).join("_"), nextAvailableIndexes, this.migrationOptions);
+  }
+  async tryReserveExecution(queueName, maxExecutions, windowMs) {
+    const nextIso = await this.getNextAvailableTime(queueName);
+    if (nextIso && new Date(nextIso).getTime() > Date.now()) {
+      return null;
+    }
+    const execDb = await this.getExecutionDb();
+    const prefixKeyValues = this.getPrefixKeyValues();
+    const windowStartIso = new Date(Date.now() - windowMs).toISOString();
+    const execTx = execDb.transaction(this.executionTableName, "readwrite");
+    const execStore = execTx.objectStore(this.executionTableName);
+    const insertedId = crypto.randomUUID();
+    return new Promise((resolve, reject) => {
+      let liveCount = 0;
+      let didInsert = false;
+      const liveRange = IDBKeyRange.bound([...prefixKeyValues, queueName, windowStartIso], [...prefixKeyValues, queueName, "￿"], true, false);
+      const cursorReq = execStore.index("queue_executed_at").openCursor(liveRange);
+      cursorReq.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          const record2 = cursor.value;
+          if (this.matchesPrefixes(record2)) {
+            liveCount++;
+          }
+          cursor.continue();
+          return;
+        }
+        if (liveCount >= maxExecutions) {
+          execTx.abort();
+          return;
+        }
+        const record = {
+          id: insertedId,
+          queue_name: queueName,
+          executed_at: new Date().toISOString()
+        };
+        for (const [k, v] of Object.entries(this.prefixValues)) {
+          record[k] = v;
+        }
+        const addReq = execStore.add(record);
+        didInsert = true;
+        addReq.onerror = () => {
+          try {
+            execTx.abort();
+          } catch {}
+          reject(addReq.error);
+        };
+      };
+      cursorReq.onerror = () => reject(cursorReq.error);
+      execTx.oncomplete = () => resolve(didInsert ? insertedId : null);
+      execTx.onerror = () => reject(execTx.error);
+      execTx.onabort = () => resolve(null);
+    });
+  }
+  async releaseExecution(queueName, token) {
+    if (token === null || token === undefined)
+      return;
+    const db = await this.getExecutionDb();
+    const tx = db.transaction(this.executionTableName, "readwrite");
+    const store = tx.objectStore(this.executionTableName);
+    return new Promise((resolve, reject) => {
+      const req = store.delete(token);
+      req.onerror = () => reject(req.error);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async recordExecution(queueName) {
+    const db = await this.getExecutionDb();
+    const tx = db.transaction(this.executionTableName, "readwrite");
+    const store = tx.objectStore(this.executionTableName);
+    const record = {
+      id: crypto.randomUUID(),
+      queue_name: queueName,
+      executed_at: new Date().toISOString()
+    };
+    for (const [key, value] of Object.entries(this.prefixValues)) {
+      record[key] = value;
+    }
+    return new Promise((resolve, reject) => {
+      const request = store.add(record);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async getExecutionCount(queueName, windowStartTime) {
+    const db = await this.getExecutionDb();
+    const tx = db.transaction(this.executionTableName, "readonly");
+    const store = tx.objectStore(this.executionTableName);
+    const index = store.index("queue_executed_at");
+    const prefixKeyValues = this.getPrefixKeyValues();
+    return new Promise((resolve, reject) => {
+      let count = 0;
+      const keyRange = IDBKeyRange.bound([...prefixKeyValues, queueName, windowStartTime], [...prefixKeyValues, queueName, "￿"], true, false);
+      const request = index.openCursor(keyRange);
+      request.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          const record = cursor.value;
+          if (this.matchesPrefixes(record)) {
+            count++;
+          }
+          cursor.continue();
+        }
+      };
+      tx.oncomplete = () => resolve(count);
+      tx.onerror = () => reject(tx.error);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async getOldestExecutionAtOffset(queueName, offset) {
+    const db = await this.getExecutionDb();
+    const tx = db.transaction(this.executionTableName, "readonly");
+    const store = tx.objectStore(this.executionTableName);
+    const index = store.index("queue_executed_at");
+    const prefixKeyValues = this.getPrefixKeyValues();
+    return new Promise((resolve, reject) => {
+      const executions = [];
+      const keyRange = IDBKeyRange.bound([...prefixKeyValues, queueName, ""], [...prefixKeyValues, queueName, "￿"]);
+      const request = index.openCursor(keyRange);
+      request.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          const record = cursor.value;
+          if (this.matchesPrefixes(record)) {
+            executions.push(record.executed_at);
+          }
+          cursor.continue();
+        }
+      };
+      tx.oncomplete = () => {
+        executions.sort();
+        resolve(executions[offset]);
+      };
+      tx.onerror = () => reject(tx.error);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async getNextAvailableTime(queueName) {
+    const db = await this.getNextAvailableDb();
+    const tx = db.transaction(this.nextAvailableTableName, "readonly");
+    const store = tx.objectStore(this.nextAvailableTableName);
+    const prefixKeyValues = this.getPrefixKeyValues();
+    const key = [...prefixKeyValues, queueName].join("_");
+    return new Promise((resolve, reject) => {
+      const request = store.get(key);
+      request.onsuccess = () => {
+        const record = request.result;
+        if (record && this.matchesPrefixes(record)) {
+          resolve(record.next_available_at);
+        } else {
+          resolve(undefined);
+        }
+      };
+      request.onerror = () => reject(request.error);
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async setNextAvailableTime(queueName, nextAvailableAt) {
+    const db = await this.getNextAvailableDb();
+    const tx = db.transaction(this.nextAvailableTableName, "readwrite");
+    const store = tx.objectStore(this.nextAvailableTableName);
+    const prefixKeyValues = this.getPrefixKeyValues();
+    const key = [...prefixKeyValues, queueName].join("_");
+    const record = {
+      queue_name: queueName,
+      next_available_at: nextAvailableAt
+    };
+    for (const [k, value] of Object.entries(this.prefixValues)) {
+      record[k] = value;
+    }
+    record[this.getPrefixColumnNames().concat(["queue_name"]).join("_")] = key;
+    return new Promise((resolve, reject) => {
+      const request = store.put(record);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async clear(queueName) {
+    const execDb = await this.getExecutionDb();
+    const execTx = execDb.transaction(this.executionTableName, "readwrite");
+    const execStore = execTx.objectStore(this.executionTableName);
+    const execIndex = execStore.index("queue_executed_at");
+    const prefixKeyValues = this.getPrefixKeyValues();
+    await new Promise((resolve, reject) => {
+      const keyRange = IDBKeyRange.bound([...prefixKeyValues, queueName, ""], [...prefixKeyValues, queueName, "￿"]);
+      const request = execIndex.openCursor(keyRange);
+      request.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          const record = cursor.value;
+          if (this.matchesPrefixes(record)) {
+            cursor.delete();
+          }
+          cursor.continue();
+        }
+      };
+      execTx.oncomplete = () => resolve();
+      execTx.onerror = () => reject(execTx.error);
+      request.onerror = () => reject(request.error);
+    });
+    const nextDb = await this.getNextAvailableDb();
+    const nextTx = nextDb.transaction(this.nextAvailableTableName, "readwrite");
+    const nextStore = nextTx.objectStore(this.nextAvailableTableName);
+    const key = [...prefixKeyValues, queueName].join("_");
+    await new Promise((resolve, reject) => {
+      const request = nextStore.delete(key);
+      nextTx.oncomplete = () => resolve();
+      nextTx.onerror = () => reject(nextTx.error);
+      request.onerror = () => reject(request.error);
+    });
+  }
+}
+export {
+  IndexedDbRateLimiterStorage,
+  IndexedDbQueueStorage,
+  INDEXED_DB_RATE_LIMITER_STORAGE,
+  INDEXED_DB_QUEUE_STORAGE
+};
+
+//# debugId=57ACA1D439B2BC0064756E2164756E21