@workglow/indexeddb 0.2.28

package/dist/storage/node.js

@@ -0,0 +1,1182 @@
+// 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;
+  }
+}
+async function dropIndexedDbTable(tableName) {
+  return deleteIndexedDbTable(tableName);
+}
+// src/storage/IndexedDbKvStorage.ts
+import { createServiceToken as createServiceToken2 } from "@workglow/util";
+
+// src/storage/IndexedDbTabularStorage.ts
+import { createServiceToken, deepEqual as deepEqual2, makeFingerprint, uuid4 } from "@workglow/util";
+import {
+  HybridSubscriptionManager,
+  BaseTabularStorage,
+  isSearchCondition,
+  pickCoveringIndex
+} from "@workglow/storage";
+var IDB_TABULAR_REPOSITORY = createServiceToken("storage.tabularRepository.indexedDb");
+function compareEntitiesForChange(a, b) {
+  const au = a?.updated_at;
+  const bu = b?.updated_at;
+  if (typeof au === "string" && typeof bu === "string") {
+    return au === bu;
+  }
+  return deepEqual2(a, b);
+}
+
+class IndexedDbTabularStorage extends BaseTabularStorage {
+  table;
+  db;
+  setupPromise = null;
+  migrationOptions;
+  hybridManager = null;
+  hybridOptions;
+  cursorSafeIndexes;
+  constructor(table = "tabular_store", schema, primaryKeyNames, indexes = [], migrationOptions = {}, clientProvidedKeys = "if-missing") {
+    super(schema, primaryKeyNames, indexes, clientProvidedKeys);
+    this.table = table;
+    this.migrationOptions = migrationOptions;
+    this.hybridOptions = {
+      useBroadcastChannel: migrationOptions.useBroadcastChannel ?? true,
+      backupPollingIntervalMs: migrationOptions.backupPollingIntervalMs ?? 5000
+    };
+  }
+  async getDb() {
+    if (this.db)
+      return this.db;
+    await this.setupDatabase();
+    return this.db;
+  }
+  async setupDatabase() {
+    if (this.db)
+      return;
+    if (this.setupPromise) {
+      await this.setupPromise;
+      return;
+    }
+    this.setupPromise = this.performSetup();
+    try {
+      this.db = await this.setupPromise;
+    } finally {
+      this.setupPromise = null;
+    }
+  }
+  async performSetup() {
+    const pkColumns = super.primaryKeyColumns();
+    const expectedIndexes = [];
+    for (const spec of this.indexes) {
+      const columns = spec;
+      if (columns.length <= pkColumns.length) {
+        const isPkPrefix = columns.every((col, idx) => col === pkColumns[idx]);
+        if (isPkPrefix)
+          continue;
+      }
+      const columnNames = columns.map((col) => String(col));
+      const indexName = columnNames.join("_");
+      expectedIndexes.push({
+        name: indexName,
+        keyPath: columnNames.length === 1 ? columnNames[0] : columnNames,
+        options: { unique: false }
+      });
+    }
+    const primaryKey = pkColumns.length === 1 ? pkColumns[0] : pkColumns;
+    const useAutoIncrement = this.hasAutoGeneratedKey() && this.autoGeneratedKeyStrategy === "autoincrement" && pkColumns.length === 1;
+    return await ensureIndexedDbTable(this.table, primaryKey, expectedIndexes, this.migrationOptions, useAutoIncrement);
+  }
+  generateKeyValue(columnName, strategy) {
+    if (strategy === "uuid") {
+      return uuid4();
+    }
+    throw new Error(`IndexedDB autoincrement keys are generated by the database, not client-side. Column: ${columnName}`);
+  }
+  async put(record) {
+    const db = await this.getDb();
+    let recordToStore = record;
+    if (this.hasAutoGeneratedKey() && this.autoGeneratedKeyName) {
+      const keyName = String(this.autoGeneratedKeyName);
+      const clientProvidedValue = record[keyName];
+      const hasClientValue = clientProvidedValue !== undefined && clientProvidedValue !== null;
+      if (this.autoGeneratedKeyStrategy === "uuid") {
+        let shouldGenerate = false;
+        if (this.clientProvidedKeys === "never") {
+          shouldGenerate = true;
+        } else if (this.clientProvidedKeys === "always") {
+          if (!hasClientValue) {
+            throw new Error(`Auto-generated key "${keyName}" is required when clientProvidedKeys is "always"`);
+          }
+          shouldGenerate = false;
+        } else {
+          shouldGenerate = !hasClientValue;
+        }
+        if (shouldGenerate) {
+          const generatedValue = this.generateKeyValue(keyName, "uuid");
+          recordToStore = { ...record, [keyName]: generatedValue };
+        }
+      } else if (this.autoGeneratedKeyStrategy === "autoincrement") {
+        if (this.clientProvidedKeys === "always" && !hasClientValue) {
+          throw new Error(`Auto-generated key "${keyName}" is required when clientProvidedKeys is "always"`);
+        }
+        if (this.clientProvidedKeys === "never") {
+          const { [keyName]: _, ...rest } = record;
+          recordToStore = rest;
+        }
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(this.table, "readwrite");
+      const store = transaction.objectStore(this.table);
+      const request = store.put(recordToStore);
+      request.onerror = () => {
+        reject(request.error);
+      };
+      request.onsuccess = () => {
+        if (this.hasAutoGeneratedKey() && this.autoGeneratedKeyName && this.autoGeneratedKeyStrategy === "autoincrement") {
+          const keyName = String(this.autoGeneratedKeyName);
+          if (recordToStore[keyName] === undefined) {
+            recordToStore = { ...recordToStore, [keyName]: request.result };
+          }
+        }
+        this.events.emit("put", recordToStore);
+        resolve(recordToStore);
+      };
+      transaction.oncomplete = () => {
+        this.hybridManager?.notifyLocalChange();
+      };
+    });
+  }
+  async putBulk(records) {
+    return await Promise.all(records.map((record) => this.put(record)));
+  }
+  getPrimaryKeyAsOrderedArray(key) {
+    return super.getPrimaryKeyAsOrderedArray(key).map((value) => typeof value === "bigint" ? value.toString() : value);
+  }
+  getIndexedKey(key) {
+    const keys = super.getPrimaryKeyAsOrderedArray(key).map((value) => typeof value === "bigint" ? value.toString() : value);
+    return keys.length === 1 ? keys[0] : keys;
+  }
+  async get(key) {
+    const db = await this.getDb();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(this.table, "readonly");
+      const store = transaction.objectStore(this.table);
+      const request = store.get(this.getIndexedKey(key));
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        if (!request.result) {
+          this.events.emit("get", key, undefined);
+          resolve(undefined);
+          return;
+        }
+        this.events.emit("get", key, request.result);
+        resolve(request.result);
+      };
+    });
+  }
+  async getAll(options) {
+    this.validateGetAllOptions(options);
+    const db = await this.getDb();
+    const transaction = db.transaction(this.table, "readonly");
+    const store = transaction.objectStore(this.table);
+    const request = store.getAll();
+    return new Promise((resolve, reject) => {
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        let values = request.result;
+        if (values.length === 0) {
+          resolve(undefined);
+          return;
+        }
+        if (options?.orderBy && options.orderBy.length > 0) {
+          values.sort((a, b) => {
+            for (const { column, direction } of options.orderBy) {
+              const aVal = a[column];
+              const bVal = b[column];
+              if (aVal == null && bVal == null)
+                continue;
+              if (aVal == null)
+                return direction === "ASC" ? -1 : 1;
+              if (bVal == null)
+                return direction === "ASC" ? 1 : -1;
+              if (aVal < bVal)
+                return direction === "ASC" ? -1 : 1;
+              if (aVal > bVal)
+                return direction === "ASC" ? 1 : -1;
+            }
+            return 0;
+          });
+        }
+        if (options?.offset !== undefined) {
+          values = values.slice(options.offset);
+        }
+        if (options?.limit !== undefined) {
+          values = values.slice(0, options.limit);
+        }
+        resolve(values.length > 0 ? values : undefined);
+      };
+    });
+  }
+  async delete(key) {
+    const db = await this.getDb();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(this.table, "readwrite");
+      const store = transaction.objectStore(this.table);
+      const request = store.delete(this.getIndexedKey(key));
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        this.events.emit("delete", key);
+        resolve();
+      };
+      transaction.oncomplete = () => {
+        this.hybridManager?.notifyLocalChange();
+      };
+    });
+  }
+  async deleteAll() {
+    const db = await this.getDb();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(this.table, "readwrite");
+      const store = transaction.objectStore(this.table);
+      const request = store.clear();
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        this.events.emit("clearall");
+        resolve();
+      };
+      transaction.oncomplete = () => {
+        this.hybridManager?.notifyLocalChange();
+      };
+    });
+  }
+  async size() {
+    const db = await this.getDb();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(this.table, "readonly");
+      const store = transaction.objectStore(this.table);
+      const request = store.count();
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result);
+    });
+  }
+  getCursorSafeIndexes() {
+    if (this.cursorSafeIndexes)
+      return this.cursorSafeIndexes;
+    const required = new Set(this.schema.required ?? []);
+    this.cursorSafeIndexes = this.indexes.filter((columns) => columns.every((column) => required.has(String(column))));
+    return this.cursorSafeIndexes;
+  }
+  createIndexedRange(store, criteria) {
+    const criteriaColumns = Object.keys(criteria);
+    if (criteriaColumns.length === 0)
+      return;
+    let best;
+    for (const indexColumns of this.getCursorSafeIndexes()) {
+      const prefixValues = [];
+      for (const column of indexColumns) {
+        const value = this.getEqualityCriterionValue(criteria, column);
+        if (value === undefined)
+          break;
+        prefixValues.push(value);
+      }
+      if (prefixValues.length === 0)
+        continue;
+      const indexedPrefix = indexColumns.slice(0, prefixValues.length);
+      const coversCriteria = criteriaColumns.every((column) => indexedPrefix.includes(column));
+      const better = !best || coversCriteria && !best.coversCriteria || coversCriteria === best.coversCriteria && prefixValues.length > best.prefixValues.length;
+      if (better) {
+        best = {
+          indexName: indexColumns.map((column) => String(column)).join("_"),
+          prefixValues,
+          fullMatch: prefixValues.length === indexColumns.length,
+          coversCriteria
+        };
+      }
+    }
+    if (!best)
+      return;
+    const range = best.fullMatch ? IDBKeyRange.only(best.prefixValues.length === 1 ? best.prefixValues[0] : best.prefixValues) : IDBKeyRange.bound(best.prefixValues, [...best.prefixValues, []]);
+    return {
+      source: store.index(best.indexName),
+      range,
+      coversCriteria: best.coversCriteria
+    };
+  }
+  async count(criteria) {
+    if (!criteria || Object.keys(criteria).length === 0) {
+      return await this.size();
+    }
+    this.validateQueryParams(criteria);
+    const db = await this.getDb();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(this.table, "readonly");
+      const store = transaction.objectStore(this.table);
+      const plan = this.createIndexedRange(store, criteria);
+      if (plan?.coversCriteria) {
+        const request2 = plan.source.count(plan.range);
+        request2.onerror = () => reject(request2.error);
+        request2.onsuccess = () => resolve(request2.result);
+        return;
+      }
+      const source = plan?.source ?? store;
+      const range = plan?.range;
+      let count = 0;
+      const request = source.openCursor(range);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        const cursor = request.result;
+        if (!cursor) {
+          resolve(count);
+          return;
+        }
+        if (this.matchesCriteria(cursor.value, criteria)) {
+          count += 1;
+        }
+        cursor.continue();
+      };
+    });
+  }
+  async getBulk(offset, limit) {
+    if (offset < 0) {
+      throw new RangeError(`offset must be non-negative, got ${offset}`);
+    }
+    if (limit <= 0) {
+      return;
+    }
+    const db = await this.getDb();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(this.table, "readonly");
+      const store = transaction.objectStore(this.table);
+      const request = store.openCursor();
+      const entities = [];
+      let skipped = false;
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        const cursor = request.result;
+        if (cursor) {
+          if (!skipped && offset > 0) {
+            skipped = true;
+            cursor.advance(offset);
+            return;
+          }
+          entities.push(cursor.value);
+          if (entities.length === limit) {
+            resolve(entities);
+            return;
+          }
+          cursor.continue();
+        } else {
+          resolve(entities.length > 0 ? entities : undefined);
+        }
+      };
+    });
+  }
+  matchesCriteria(record, criteria) {
+    for (const column of Object.keys(criteria)) {
+      const criterion = criteria[column];
+      const recordValue = record[column];
+      let operator = "=";
+      let value;
+      if (isSearchCondition(criterion)) {
+        operator = criterion.operator;
+        value = criterion.value;
+      } else {
+        value = criterion;
+      }
+      if (operator !== "=" && (recordValue === null || recordValue === undefined)) {
+        return false;
+      }
+      switch (operator) {
+        case "=":
+          if (recordValue !== value)
+            return false;
+          break;
+        case "<":
+          if (!(recordValue < value))
+            return false;
+          break;
+        case "<=":
+          if (!(recordValue <= value))
+            return false;
+          break;
+        case ">":
+          if (!(recordValue > value))
+            return false;
+          break;
+        case ">=":
+          if (!(recordValue >= value))
+            return false;
+          break;
+        default:
+          return false;
+      }
+    }
+    return true;
+  }
+  async deleteSearch(criteria) {
+    const criteriaKeys = Object.keys(criteria);
+    if (criteriaKeys.length === 0) {
+      return;
+    }
+    const db = await this.getDb();
+    return new Promise(async (resolve, reject) => {
+      try {
+        const transaction = db.transaction(this.table, "readwrite");
+        const store = transaction.objectStore(this.table);
+        transaction.oncomplete = () => {
+          this.events.emit("delete", criteriaKeys[0]);
+          this.hybridManager?.notifyLocalChange();
+          resolve();
+        };
+        transaction.onerror = () => {
+          reject(transaction.error);
+        };
+        const getAllRequest = store.getAll();
+        getAllRequest.onsuccess = () => {
+          const allRecords = getAllRequest.result;
+          const recordsToDelete = allRecords.filter((record) => this.matchesCriteria(record, criteria));
+          if (recordsToDelete.length === 0) {
+            return;
+          }
+          for (const record of recordsToDelete) {
+            const primaryKey = this.primaryKeyColumns().reduce((key, col) => {
+              key[col] = record[col];
+              return key;
+            }, {});
+            const request = store.delete(this.getIndexedKey(primaryKey));
+            request.onerror = () => {
+              console.error("Error deleting record:", request.error);
+            };
+          }
+        };
+        getAllRequest.onerror = () => {
+          reject(getAllRequest.error);
+        };
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  getEqualityCriterionValue(criteria, column) {
+    const criterion = criteria[column];
+    if (criterion === undefined)
+      return;
+    if (isSearchCondition(criterion)) {
+      return criterion.operator === "=" ? criterion.value : undefined;
+    }
+    return criterion;
+  }
+  compareByOrder(a, b, options) {
+    if (!options?.orderBy)
+      return 0;
+    for (const { column, direction } of options.orderBy) {
+      const aVal = a[column];
+      const bVal = b[column];
+      if (aVal == null && bVal == null)
+        continue;
+      if (aVal == null)
+        return direction === "ASC" ? -1 : 1;
+      if (bVal == null)
+        return direction === "ASC" ? 1 : -1;
+      if (aVal < bVal)
+        return direction === "ASC" ? -1 : 1;
+      if (aVal > bVal)
+        return direction === "ASC" ? 1 : -1;
+    }
+    return 0;
+  }
+  createIndexedQuery(store, criteria, options) {
+    const orderBy = options?.orderBy ?? [];
+    let best;
+    for (const indexColumns of this.getCursorSafeIndexes()) {
+      const prefixValues = [];
+      for (const column of indexColumns) {
+        const value = this.getEqualityCriterionValue(criteria, column);
+        if (value === undefined)
+          break;
+        prefixValues.push(value);
+      }
+      if (prefixValues.length === 0)
+        continue;
+      const remainingColumns = indexColumns.slice(prefixValues.length);
+      let redundantOrderPrefixLength = 0;
+      while (redundantOrderPrefixLength < orderBy.length && redundantOrderPrefixLength < prefixValues.length && orderBy[redundantOrderPrefixLength]?.column === indexColumns[redundantOrderPrefixLength]) {
+        redundantOrderPrefixLength++;
+      }
+      const normalizedOrderBy = orderBy.slice(redundantOrderPrefixLength);
+      const satisfiesOrder = normalizedOrderBy.length === 0 || normalizedOrderBy.length <= remainingColumns.length && normalizedOrderBy.every((order, index) => order.column === remainingColumns[index]) && orderBy.every((order) => order.direction === orderBy[0]?.direction);
+      if (!satisfiesOrder && best)
+        continue;
+      if (!best || satisfiesOrder && !best.satisfiesOrder || prefixValues.length > best.prefixValues.length) {
+        best = {
+          indexName: indexColumns.map((column) => String(column)).join("_"),
+          prefixValues,
+          fullMatch: prefixValues.length === indexColumns.length,
+          satisfiesOrder,
+          direction: orderBy[0]?.direction === "DESC" ? "prev" : "next"
+        };
+      }
+    }
+    const appliedLimit = Boolean(best?.satisfiesOrder && options?.limit !== undefined);
+    const appliedOffset = Boolean(best?.satisfiesOrder && options?.offset !== undefined);
+    if (!best) {
+      return {
+        source: store,
+        range: undefined,
+        direction: orderBy[0]?.direction === "DESC" ? "prev" : "next",
+        satisfiesOrder: false,
+        appliedLimit: false,
+        appliedOffset: false,
+        skipRemaining: 0
+      };
+    }
+    const source = store.index(best.indexName);
+    const keyRange = best.fullMatch ? IDBKeyRange.only(best.prefixValues.length === 1 ? best.prefixValues[0] : best.prefixValues) : IDBKeyRange.bound(best.prefixValues, [...best.prefixValues, []]);
+    return {
+      source,
+      range: keyRange,
+      direction: best.direction,
+      satisfiesOrder: best.satisfiesOrder,
+      appliedLimit,
+      appliedOffset,
+      skipRemaining: appliedOffset ? options?.offset ?? 0 : 0
+    };
+  }
+  async query(criteria, options) {
+    this.validateQueryParams(criteria, options);
+    const db = await this.getDb();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(this.table, "readonly");
+      const store = transaction.objectStore(this.table);
+      const indexedQuery = this.createIndexedQuery(store, criteria, options);
+      const results = [];
+      const request = indexedQuery.source.openCursor(indexedQuery.range, indexedQuery.direction);
+      request.onsuccess = () => {
+        const cursor = request.result;
+        if (!cursor) {
+          let finalResults = results;
+          if (!indexedQuery.satisfiesOrder && options?.orderBy && options.orderBy.length > 0) {
+            finalResults = [...finalResults].sort((a, b) => this.compareByOrder(a, b, options));
+          }
+          if (!indexedQuery.appliedOffset && options?.offset !== undefined) {
+            finalResults = finalResults.slice(options.offset);
+          }
+          if (!indexedQuery.appliedLimit && options?.limit !== undefined) {
+            finalResults = finalResults.slice(0, options.limit);
+          }
+          const result = finalResults.length > 0 ? finalResults : undefined;
+          this.events.emit("query", criteria, result);
+          resolve(result);
+          return;
+        }
+        const record = cursor.value;
+        if (this.matchesCriteria(record, criteria)) {
+          if (indexedQuery.skipRemaining > 0) {
+            indexedQuery.skipRemaining -= 1;
+          } else {
+            results.push(record);
+            if (indexedQuery.appliedLimit && results.length === options?.limit) {
+              const result = results.length > 0 ? results : undefined;
+              this.events.emit("query", criteria, result);
+              resolve(result);
+              return;
+            }
+          }
+        }
+        cursor.continue();
+      };
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async queryIndex(criteria, options) {
+    this.validateSelect(options);
+    this.validateQueryParams(criteria, options);
+    const registered = this.indexes.map((cols) => {
+      const cs = Array.isArray(cols) ? cols : [cols];
+      return { name: cs.join("_"), keyPath: cs };
+    });
+    const picked = pickCoveringIndex({
+      table: this.table,
+      indexes: registered,
+      criteriaColumns: Object.keys(criteria),
+      orderByColumns: (options.orderBy ?? []).map((o) => ({
+        column: String(o.column),
+        direction: o.direction
+      })),
+      selectColumns: options.select.map(String),
+      primaryKeyColumns: this.primaryKeyColumns().map(String)
+    });
+    const db = await this.getDb();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.table, "readonly");
+      const store = tx.objectStore(this.table);
+      const idx = store.index(picked.name);
+      const prefix = [];
+      for (const col of picked.keyPath) {
+        const c = criteria[col];
+        if (c === undefined && !(col in criteria))
+          break;
+        if (isSearchCondition(c)) {
+          if (c.operator !== "=")
+            break;
+          prefix.push(c.value);
+        } else {
+          prefix.push(c);
+        }
+      }
+      const range = prefix.length === 0 ? undefined : prefix.length === picked.keyPath.length ? IDBKeyRange.only(prefix.length === 1 ? prefix[0] : prefix) : IDBKeyRange.bound(prefix, [...prefix, []]);
+      const direction = picked.reverseDirection ? "prev" : "next";
+      const request = idx.openKeyCursor(range, direction);
+      const out = [];
+      let toSkip = options.offset ?? 0;
+      const keyPathPositions = new Map;
+      picked.keyPath.forEach((col, i) => keyPathPositions.set(col, i));
+      const pkCols = this.primaryKeyColumns().map(String);
+      const pkPositions = new Map;
+      pkCols.forEach((col, i) => pkPositions.set(col, i));
+      request.onsuccess = () => {
+        const cursor = request.result;
+        if (!cursor) {
+          resolve(out);
+          return;
+        }
+        const key = cursor.key;
+        const row = {};
+        for (const col of options.select) {
+          const colStr = String(col);
+          const pos = keyPathPositions.get(colStr);
+          if (pos !== undefined) {
+            row[colStr] = Array.isArray(key) ? key[pos] : key;
+          } else {
+            if (pkCols.length === 1 && colStr === pkCols[0]) {
+              row[colStr] = cursor.primaryKey;
+            } else {
+              const pkPos = pkPositions.get(colStr);
+              if (pkPos !== undefined) {
+                row[colStr] = Array.isArray(cursor.primaryKey) ? cursor.primaryKey[pkPos] : cursor.primaryKey;
+              }
+            }
+          }
+        }
+        let matches = true;
+        for (const [col, crit] of Object.entries(criteria)) {
+          const pos = keyPathPositions.get(col);
+          if (pos === undefined)
+            continue;
+          if (pos < prefix.length)
+            continue;
+          const valFromKey = Array.isArray(key) ? key[pos] : key;
+          const op = isSearchCondition(crit) ? crit.operator : "=";
+          const val = isSearchCondition(crit) ? crit.value : crit;
+          if (!compareWithOperator(valFromKey, op, val)) {
+            matches = false;
+            break;
+          }
+        }
+        if (matches) {
+          if (toSkip > 0) {
+            toSkip -= 1;
+          } else {
+            out.push(row);
+            if (options.limit !== undefined && out.length >= options.limit) {
+              resolve(out);
+              return;
+            }
+          }
+        }
+        cursor.continue();
+      };
+      request.onerror = () => reject(request.error);
+    });
+  }
+  getHybridManager() {
+    if (!this.hybridManager) {
+      const channelName = `indexeddb-tabular-${this.table}`;
+      this.hybridManager = new HybridSubscriptionManager(channelName, async () => {
+        const entities = await this.getAll() || [];
+        const map = new Map;
+        for (const entity of entities) {
+          const { key } = this.separateKeyValueFromCombined(entity);
+          const fingerprint = await makeFingerprint(key);
+          map.set(fingerprint, entity);
+        }
+        return map;
+      }, compareEntitiesForChange, {
+        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;
+  }
+  subscribeToChanges(callback, options) {
+    const intervalMs = options?.pollingIntervalMs ?? 1000;
+    const manager = this.getHybridManager();
+    return manager.subscribe(callback, { intervalMs });
+  }
+  destroy() {
+    if (this.hybridManager) {
+      this.hybridManager.destroy();
+      this.hybridManager = null;
+    }
+    this.db?.close();
+  }
+}
+function compareWithOperator(a, op, b) {
+  const av = a;
+  const bv = b;
+  switch (op) {
+    case "=":
+      return av === bv;
+    case "<":
+      return av !== null && av !== undefined && av < bv;
+    case "<=":
+      return av !== null && av !== undefined && av <= bv;
+    case ">":
+      return av !== null && av !== undefined && av > bv;
+    case ">=":
+      return av !== null && av !== undefined && av >= bv;
+  }
+}
+
+// src/storage/IndexedDbKvStorage.ts
+import {
+  DefaultKeyValueKey,
+  DefaultKeyValueSchema,
+  KvViaTabularStorage
+} from "@workglow/storage";
+var IDB_KV_REPOSITORY = createServiceToken2("storage.kvRepository.indexedDb");
+
+class IndexedDbKvStorage extends KvViaTabularStorage {
+  dbName;
+  tabularRepository;
+  constructor(dbName, keySchema = { type: "string" }, valueSchema = {}) {
+    super(keySchema, valueSchema);
+    this.dbName = dbName;
+    this.tabularRepository = new IndexedDbTabularStorage(dbName, DefaultKeyValueSchema, DefaultKeyValueKey);
+  }
+}
+// src/storage/IndexedDbVectorStorage.ts
+import { createServiceToken as createServiceToken3 } from "@workglow/util";
+import { cosineSimilarity } from "@workglow/util/schema";
+import { getMetadataProperty, getVectorProperty } from "@workglow/storage";
+var IDB_VECTOR_REPOSITORY = createServiceToken3("storage.vectorRepository.indexedDb");
+function matchesFilter(metadata, filter) {
+  for (const [key, value] of Object.entries(filter)) {
+    if (metadata[key] !== value) {
+      return false;
+    }
+  }
+  return true;
+}
+function textRelevance(text, query) {
+  const textLower = text.toLowerCase();
+  const queryLower = query.toLowerCase();
+  const queryWords = queryLower.split(/\s+/).filter((w) => w.length > 0);
+  if (queryWords.length === 0) {
+    return 0;
+  }
+  let matches = 0;
+  for (const word of queryWords) {
+    if (textLower.includes(word)) {
+      matches++;
+    }
+  }
+  return matches / queryWords.length;
+}
+
+class IndexedDbVectorStorage extends IndexedDbTabularStorage {
+  vectorDimensions;
+  vectorPropertyName;
+  metadataPropertyName;
+  constructor(table = "vectors", schema, primaryKeyNames, indexes = [], dimensions, _vectorCtor = Float32Array, migrationOptions = {}, clientProvidedKeys = "if-missing") {
+    super(table, schema, primaryKeyNames, indexes, migrationOptions, clientProvidedKeys);
+    this.vectorDimensions = dimensions;
+    const vectorProp = getVectorProperty(schema);
+    if (!vectorProp) {
+      throw new Error("Schema must have a property with type array and format TypedArray");
+    }
+    this.vectorPropertyName = vectorProp;
+    this.metadataPropertyName = getMetadataProperty(schema);
+  }
+  getVectorDimensions() {
+    return this.vectorDimensions;
+  }
+  async similaritySearch(query, options = {}) {
+    const { topK = 10, filter, scoreThreshold = 0 } = options;
+    const results = [];
+    const allEntities = await this.getAll() || [];
+    for (const entity of allEntities) {
+      const vector = entity[this.vectorPropertyName];
+      const metadata = this.metadataPropertyName ? entity[this.metadataPropertyName] : {};
+      if (filter && !matchesFilter(metadata, filter)) {
+        continue;
+      }
+      const score = cosineSimilarity(query, vector);
+      if (score < scoreThreshold) {
+        continue;
+      }
+      results.push({
+        ...entity,
+        score
+      });
+    }
+    results.sort((a, b) => b.score - a.score);
+    const topResults = results.slice(0, topK);
+    return topResults;
+  }
+  async hybridSearch(query, options) {
+    const { topK = 10, filter, scoreThreshold = 0, textQuery, vectorWeight = 0.7 } = options;
+    if (!textQuery || textQuery.trim().length === 0) {
+      return this.similaritySearch(query, { topK, filter, scoreThreshold });
+    }
+    const results = [];
+    const allEntities = await this.getAll() || [];
+    for (const entity of allEntities) {
+      const vector = entity[this.vectorPropertyName];
+      const metadata = this.metadataPropertyName ? entity[this.metadataPropertyName] : {};
+      if (filter && !matchesFilter(metadata, filter)) {
+        continue;
+      }
+      const vectorScore = cosineSimilarity(query, vector);
+      const metadataText = Object.values(metadata).join(" ").toLowerCase();
+      const textScore = textRelevance(metadataText, textQuery);
+      const combinedScore = vectorWeight * vectorScore + (1 - vectorWeight) * textScore;
+      if (combinedScore < scoreThreshold) {
+        continue;
+      }
+      results.push({
+        ...entity,
+        score: combinedScore
+      });
+    }
+    results.sort((a, b) => b.score - a.score);
+    const topResults = results.slice(0, topK);
+    return topResults;
+  }
+}
+export {
+  ensureIndexedDbTable,
+  dropIndexedDbTable,
+  IndexedDbVectorStorage,
+  IndexedDbTabularStorage,
+  IndexedDbKvStorage,
+  IDB_VECTOR_REPOSITORY,
+  IDB_TABULAR_REPOSITORY,
+  IDB_KV_REPOSITORY
+};
+
+//# debugId=D7674124BFA18F0C64756E2164756E21