@xyo-network/archivist-indexeddb 2.87.1 → 2.88.0

package/dist/node/index.js

@@ -7,7 +7,6 @@ var __publicField = (obj, key, value) => {
 };
 
 // src/Archivist.ts
-import { assertEx } from "@xylabs/assert";
 import { exists } from "@xylabs/exists";
 import { AbstractArchivist } from "@xyo-network/archivist-abstract";
 import { ArchivistAllQuerySchema, ArchivistClearQuerySchema, ArchivistDeleteQuerySchema, ArchivistInsertQuerySchema, buildStandardIndexName } from "@xyo-network/archivist-model";
@@ -34,7 +33,6 @@ function _ts_decorate(decorators, target, key, desc) {
 }
 __name(_ts_decorate, "_ts_decorate");
 var _IndexedDbArchivist = class _IndexedDbArchivist extends AbstractArchivist {
-  _db;
   /**
   * The database name. If not supplied via config, it defaults
   * to the module name (not guaranteed to be unique) and if module
@@ -70,76 +68,108 @@ var _IndexedDbArchivist = class _IndexedDbArchivist extends AbstractArchivist {
     var _a;
     return ((_a = this.config) == null ? void 0 : _a.storeName) ?? _IndexedDbArchivist.defaultStoreName;
   }
-  get db() {
-    return assertEx(this._db, "DB not initialized");
-  }
+  /**
+  * The indexes to create on the store
+  */
   get indexes() {
     var _a, _b;
-    return ((_b = (_a = this.config) == null ? void 0 : _a.storage) == null ? void 0 : _b.indexes) ?? [];
+    return [
+      _IndexedDbArchivist.hashIndex,
+      _IndexedDbArchivist.schemaIndex,
+      ...((_b = (_a = this.config) == null ? void 0 : _a.storage) == null ? void 0 : _b.indexes) ?? []
+    ];
   }
   async allHandler() {
-    const payloads = await this.db.getAll(this.storeName);
+    const payloads = await this.useDb((db) => db.getAll(this.storeName));
     return payloads.map((payload) => PayloadHasher.jsonPayload(payload));
   }
   async clearHandler() {
-    await this.db.clear(this.storeName);
+    await this.useDb((db) => db.clear(this.storeName));
   }
   async deleteHandler(hashes) {
     const distinctHashes = [
       ...new Set(hashes)
     ];
-    const found = await Promise.all(distinctHashes.map(async (hash) => {
-      let existing;
-      do {
-        existing = await this.db.getKeyFromIndex(this.storeName, _IndexedDbArchivist.hashIndexName, hash);
-        if (existing)
-          await this.db.delete(this.storeName, existing);
-      } while (!existing);
-      return hash;
-    }));
-    return found.filter(exists);
+    return await this.useDb(async (db) => {
+      const found = await Promise.all(distinctHashes.map(async (hash) => {
+        const existing = await db.getKeyFromIndex(this.storeName, _IndexedDbArchivist.hashIndexName, hash);
+        if (existing) {
+          await db.delete(this.storeName, existing);
+          return hash;
+        }
+      }));
+      return found.filter(exists);
+    });
   }
   async getHandler(hashes) {
-    const payloads = await Promise.all(hashes.map((hash) => this.db.getFromIndex(this.storeName, _IndexedDbArchivist.hashIndexName, hash)));
+    const payloads = await this.useDb((db) => Promise.all(hashes.map((hash) => db.getFromIndex(this.storeName, _IndexedDbArchivist.hashIndexName, hash))));
     return payloads.filter(exists);
   }
   async insertHandler(payloads) {
     const pairs = await PayloadHasher.hashPairs(payloads);
-    const inserted = await Promise.all(pairs.map(async ([payload, _hash]) => {
-      const tx = this.db.transaction(this.storeName, "readwrite");
-      try {
-        const store = tx.objectStore(this.storeName);
-        const existing = await store.index(_IndexedDbArchivist.hashIndexName).get(_hash);
-        if (!existing) {
-          await store.put({
-            ...payload,
-            _hash
-          });
-          return payload;
+    const db = await this.getInitializedDb();
+    try {
+      const inserted = await Promise.all(pairs.map(async ([payload, _hash]) => {
+        const tx = db.transaction(this.storeName, "readwrite");
+        try {
+          const store = tx.objectStore(this.storeName);
+          const existing = await store.index(_IndexedDbArchivist.hashIndexName).get(_hash);
+          if (!existing) {
+            await store.put({
+              ...payload,
+              _hash
+            });
+            return payload;
+          }
+        } finally {
+          await tx.done;
         }
-      } finally {
-        await tx.done;
-      }
-    }));
-    return inserted.filter(exists);
+      }));
+      return inserted.filter(exists);
+    } finally {
+      db.close();
+    }
   }
   async startHandler() {
     await super.startHandler();
+    await this.useDb(() => {
+    });
+    return true;
+  }
+  /**
+  * Returns that the desired DB/Store initialized to the correct version
+  * @returns The initialized DB
+  */
+  async getInitializedDb() {
     const { dbName, dbVersion, indexes, storeName } = this;
-    this._db = await openDB(dbName, dbVersion, {
-      async upgrade(database) {
-        await Promise.resolve();
+    const db = await openDB(dbName, dbVersion, {
+      blocked(currentVersion, blockedVersion, event) {
+        console.warn(`IndexedDbArchivist: Blocked from upgrading from ${currentVersion} to ${blockedVersion}`, event);
+      },
+      blocking(currentVersion, blockedVersion, event) {
+        console.warn(`IndexedDbArchivist: Blocking upgrade from ${currentVersion} to ${blockedVersion}`, event);
+      },
+      terminated() {
+        console.log("IndexedDbArchivist: Terminated");
+      },
+      upgrade(database, oldVersion, newVersion, transaction) {
+        if (oldVersion !== newVersion) {
+          console.log(`IndexedDbArchivist: Upgrading from ${oldVersion} to ${newVersion}`);
+          const objectStores = transaction.objectStoreNames;
+          for (const name of objectStores) {
+            try {
+              database.deleteObjectStore(name);
+            } catch {
+              console.log(`IndexedDbArchivist: Failed to delete existing object store ${name}`);
+            }
+          }
+        }
         const store = database.createObjectStore(storeName, {
           // If it isn't explicitly set, create a value by auto incrementing.
           autoIncrement: true
         });
         store.name = storeName;
-        const indexesToCreate = [
-          _IndexedDbArchivist.hashIndex,
-          _IndexedDbArchivist.schemaIndex,
-          ...indexes
-        ];
-        for (const { key, multiEntry, unique } of indexesToCreate) {
+        for (const { key, multiEntry, unique } of indexes) {
           const indexKeys = Object.keys(key);
           const keys = indexKeys.length === 1 ? indexKeys[0] : indexKeys;
           const indexName = buildStandardIndexName({
@@ -153,7 +183,20 @@ var _IndexedDbArchivist = class _IndexedDbArchivist extends AbstractArchivist {
         }
       }
     });
-    return true;
+    return db;
+  }
+  /**
+  * Executes a callback with the initialized DB and then closes the db
+  * @param callback The method to execute with the initialized DB
+  * @returns
+  */
+  async useDb(callback) {
+    const db = await this.getInitializedDb();
+    try {
+      return await callback(db);
+    } finally {
+      db.close();
+    }
   }
 };
 __name(_IndexedDbArchivist, "IndexedDbArchivist");

package/dist/node/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/Archivist.ts","../../src/Schema.ts","../../src/Config.ts"],"sourcesContent":["import { assertEx } from '@xylabs/assert'\nimport { exists } from '@xylabs/exists'\nimport { AbstractArchivist } from '@xyo-network/archivist-abstract'\nimport {\n  ArchivistAllQuerySchema,\n  ArchivistClearQuerySchema,\n  ArchivistDeleteQuerySchema,\n  ArchivistInsertQuerySchema,\n  ArchivistModuleEventData,\n  buildStandardIndexName,\n  IndexDescription,\n} from '@xyo-network/archivist-model'\nimport { PayloadHasher } from '@xyo-network/hash'\nimport { creatableModule } from '@xyo-network/module-model'\nimport { Payload } from '@xyo-network/payload-model'\nimport { IDBPDatabase, openDB } from 'idb'\n\nimport { IndexedDbArchivistConfigSchema } from './Config'\nimport { IndexedDbArchivistParams } from './Params'\n\nexport interface PayloadStore {\n  [s: string]: Payload\n}\n\n@creatableModule()\nexport class IndexedDbArchivist<\n  TParams extends IndexedDbArchivistParams = IndexedDbArchivistParams,\n  TEventData extends ArchivistModuleEventData = ArchivistModuleEventData,\n> extends AbstractArchivist<TParams, TEventData> {\n  static override configSchemas = [IndexedDbArchivistConfigSchema]\n  static readonly defaultDbName = 'archivist'\n  static readonly defaultDbVersion = 1\n  static readonly defaultStoreName = 'payloads'\n  private static readonly hashIndex: IndexDescription = { key: { _hash: 1 }, multiEntry: false, unique: true }\n  private static readonly schemaIndex: IndexDescription = { key: { schema: 1 }, multiEntry: false, unique: false }\n  // eslint-disable-next-line @typescript-eslint/member-ordering\n  static readonly hashIndexName = buildStandardIndexName(IndexedDbArchivist.hashIndex)\n  // eslint-disable-next-line @typescript-eslint/member-ordering\n  static readonly schemaIndexName = buildStandardIndexName(IndexedDbArchivist.schemaIndex)\n\n  private _db: IDBPDatabase<PayloadStore> | undefined\n\n  /**\n   * The database name. If not supplied via config, it defaults\n   * to the module name (not guaranteed to be unique) and if module\n   * name is not supplied, it defaults to `archivist`. This behavior\n   * biases towards a single, isolated DB per archivist which seems to\n   * make the most sense for 99% of use cases.\n   */\n  get dbName() {\n    return this.config?.dbName ?? this.config?.name ?? IndexedDbArchivist.defaultDbName\n  }\n\n  /**\n   * The database version. If not supplied via config, it defaults to 1.\n   */\n  get dbVersion() {\n    return this.config?.dbVersion ?? IndexedDbArchivist.defaultDbVersion\n  }\n\n  override get queries() {\n    return [ArchivistAllQuerySchema, ArchivistClearQuerySchema, ArchivistDeleteQuerySchema, ArchivistInsertQuerySchema, ...super.queries]\n  }\n\n  /**\n   * The name of the object store. If not supplied via config, it defaults\n   * to `payloads`.\n   */\n  get storeName() {\n    return this.config?.storeName ?? IndexedDbArchivist.defaultStoreName\n  }\n\n  private get db(): IDBPDatabase<PayloadStore> {\n    return assertEx(this._db, 'DB not initialized')\n  }\n\n  private get indexes() {\n    return this.config?.storage?.indexes ?? []\n  }\n\n  protected override async allHandler(): Promise<Payload[]> {\n    // Get all payloads from the store\n    const payloads = await this.db.getAll(this.storeName)\n    // Remove any metadata before returning to the client\n    return payloads.map((payload) => PayloadHasher.jsonPayload(payload))\n  }\n\n  protected override async clearHandler(): Promise<void> {\n    await this.db.clear(this.storeName)\n  }\n\n  protected override async deleteHandler(hashes: string[]): Promise<string[]> {\n    const distinctHashes = [...new Set(hashes)]\n    const found = await Promise.all(\n      distinctHashes.map(async (hash) => {\n        let existing: IDBValidKey | undefined\n        do {\n          existing = await this.db.getKeyFromIndex(this.storeName, IndexedDbArchivist.hashIndexName, hash)\n          if (existing) await this.db.delete(this.storeName, existing)\n        } while (!existing)\n        return hash\n      }),\n    )\n    // Return hashes removed\n    return found.filter(exists)\n  }\n\n  protected override async getHandler(hashes: string[]): Promise<Payload[]> {\n    const payloads = await Promise.all(hashes.map((hash) => this.db.getFromIndex(this.storeName, IndexedDbArchivist.hashIndexName, hash)))\n    return payloads.filter(exists)\n  }\n\n  protected override async insertHandler(payloads: Payload[]): Promise<Payload[]> {\n    const pairs = await PayloadHasher.hashPairs(payloads)\n    // Only return the payloads that were successfully inserted\n    const inserted = await Promise.all(\n      pairs.map(async ([payload, _hash]) => {\n        const tx = this.db.transaction(this.storeName, 'readwrite')\n        try {\n          const store = tx.objectStore(this.storeName)\n          const existing = await store.index(IndexedDbArchivist.hashIndexName).get(_hash)\n          if (!existing) {\n            await store.put({ ...payload, _hash })\n            return payload\n          }\n        } finally {\n          await tx.done\n        }\n      }),\n    )\n    return inserted.filter(exists)\n  }\n\n  protected override async startHandler() {\n    await super.startHandler()\n    // NOTE: We could defer this creation to first access but we\n    // want to fail fast here in case something is wrong\n    const { dbName, dbVersion, indexes, storeName } = this\n    this._db = await openDB<PayloadStore>(dbName, dbVersion, {\n      async upgrade(database) {\n        await Promise.resolve() // Async to match spec\n        // Create the store\n        const store = database.createObjectStore(storeName, {\n          // If it isn't explicitly set, create a value by auto incrementing.\n          autoIncrement: true,\n        })\n        // Name the store\n        store.name = storeName\n        // Create an index on the hash\n        const indexesToCreate = [IndexedDbArchivist.hashIndex, IndexedDbArchivist.schemaIndex, ...indexes]\n        for (const { key, multiEntry, unique } of indexesToCreate) {\n          const indexKeys = Object.keys(key)\n          const keys = indexKeys.length === 1 ? indexKeys[0] : indexKeys\n          const indexName = buildStandardIndexName({ key, unique })\n          store.createIndex(indexName, keys, { multiEntry, unique })\n        }\n      },\n    })\n    return true\n  }\n}\n","export type IndexedDbArchivistSchema = 'network.xyo.archivist.indexeddb'\nexport const IndexedDbArchivistSchema: IndexedDbArchivistSchema = 'network.xyo.archivist.indexeddb'\n","import { ArchivistConfig, IndexDescription } from '@xyo-network/archivist-model'\n\nimport { IndexedDbArchivistSchema } from './Schema'\n\nexport type IndexedDbArchivistConfigSchema = `${IndexedDbArchivistSchema}.config`\nexport const IndexedDbArchivistConfigSchema: IndexedDbArchivistConfigSchema = `${IndexedDbArchivistSchema}.config`\n\nexport type IndexedDbArchivistConfig = ArchivistConfig<{\n  /**\n   * The database name\n   */\n  dbName?: string\n  /**\n   * The version of the DB, defaults to 1\n   */\n  dbVersion?: number\n  schema: IndexedDbArchivistConfigSchema\n  /**\n   * The storage configuration\n   * // TODO: Hoist to main archivist config\n   */\n  storage?: {\n    /**\n     * The indexes to create on the object store\n     */\n    indexes?: IndexDescription[]\n  }\n  /**\n   * The name of the object store\n   */\n  storeName?: string\n}>\n"],"mappings":"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","names":["assertEx","exists","AbstractArchivist","ArchivistAllQuerySchema","ArchivistClearQuerySchema","ArchivistDeleteQuerySchema","ArchivistInsertQuerySchema","buildStandardIndexName","PayloadHasher","creatableModule","openDB","IndexedDbArchivistSchema","IndexedDbArchivistConfigSchema","IndexedDbArchivistSchema","IndexedDbArchivist","AbstractArchivist","_db","dbName","config","name","defaultDbName","dbVersion","defaultDbVersion","queries","ArchivistAllQuerySchema","ArchivistClearQuerySchema","ArchivistDeleteQuerySchema","ArchivistInsertQuerySchema","storeName","defaultStoreName","db","assertEx","indexes","storage","allHandler","payloads","getAll","map","payload","PayloadHasher","jsonPayload","clearHandler","clear","deleteHandler","hashes","distinctHashes","Set","found","Promise","all","hash","existing","getKeyFromIndex","hashIndexName","delete","filter","exists","getHandler","getFromIndex","insertHandler","pairs","hashPairs","inserted","_hash","tx","transaction","store","objectStore","index","get","put","done","startHandler","openDB","upgrade","database","resolve","createObjectStore","autoIncrement","indexesToCreate","hashIndex","schemaIndex","key","multiEntry","unique","indexKeys","Object","keys","length","indexName","buildStandardIndexName","createIndex","configSchemas","IndexedDbArchivistConfigSchema","schema","schemaIndexName","creatableModule"]}
+{"version":3,"sources":["../../src/Archivist.ts","../../src/Schema.ts","../../src/Config.ts"],"sourcesContent":["import { exists } from '@xylabs/exists'\nimport { AbstractArchivist } from '@xyo-network/archivist-abstract'\nimport {\n  ArchivistAllQuerySchema,\n  ArchivistClearQuerySchema,\n  ArchivistDeleteQuerySchema,\n  ArchivistInsertQuerySchema,\n  ArchivistModuleEventData,\n  buildStandardIndexName,\n  IndexDescription,\n} from '@xyo-network/archivist-model'\nimport { PayloadHasher } from '@xyo-network/hash'\nimport { creatableModule } from '@xyo-network/module-model'\nimport { Payload } from '@xyo-network/payload-model'\nimport { IDBPDatabase, openDB } from 'idb'\n\nimport { IndexedDbArchivistConfigSchema } from './Config'\nimport { IndexedDbArchivistParams } from './Params'\n\nexport interface PayloadStore {\n  [s: string]: Payload\n}\n\n@creatableModule()\nexport class IndexedDbArchivist<\n  TParams extends IndexedDbArchivistParams = IndexedDbArchivistParams,\n  TEventData extends ArchivistModuleEventData = ArchivistModuleEventData,\n> extends AbstractArchivist<TParams, TEventData> {\n  static override configSchemas = [IndexedDbArchivistConfigSchema]\n  static readonly defaultDbName = 'archivist'\n  static readonly defaultDbVersion = 1\n  static readonly defaultStoreName = 'payloads'\n  private static readonly hashIndex: IndexDescription = { key: { _hash: 1 }, multiEntry: false, unique: true }\n  private static readonly schemaIndex: IndexDescription = { key: { schema: 1 }, multiEntry: false, unique: false }\n  // eslint-disable-next-line @typescript-eslint/member-ordering\n  static readonly hashIndexName = buildStandardIndexName(IndexedDbArchivist.hashIndex)\n  // eslint-disable-next-line @typescript-eslint/member-ordering\n  static readonly schemaIndexName = buildStandardIndexName(IndexedDbArchivist.schemaIndex)\n\n  /**\n   * The database name. If not supplied via config, it defaults\n   * to the module name (not guaranteed to be unique) and if module\n   * name is not supplied, it defaults to `archivist`. This behavior\n   * biases towards a single, isolated DB per archivist which seems to\n   * make the most sense for 99% of use cases.\n   */\n  get dbName() {\n    return this.config?.dbName ?? this.config?.name ?? IndexedDbArchivist.defaultDbName\n  }\n\n  /**\n   * The database version. If not supplied via config, it defaults to 1.\n   */\n  get dbVersion() {\n    return this.config?.dbVersion ?? IndexedDbArchivist.defaultDbVersion\n  }\n\n  override get queries() {\n    return [ArchivistAllQuerySchema, ArchivistClearQuerySchema, ArchivistDeleteQuerySchema, ArchivistInsertQuerySchema, ...super.queries]\n  }\n\n  /**\n   * The name of the object store. If not supplied via config, it defaults\n   * to `payloads`.\n   */\n  get storeName() {\n    return this.config?.storeName ?? IndexedDbArchivist.defaultStoreName\n  }\n\n  /**\n   * The indexes to create on the store\n   */\n  private get indexes() {\n    return [IndexedDbArchivist.hashIndex, IndexedDbArchivist.schemaIndex, ...(this.config?.storage?.indexes ?? [])]\n  }\n\n  protected override async allHandler(): Promise<Payload[]> {\n    // Get all payloads from the store\n    const payloads = await this.useDb((db) => db.getAll(this.storeName))\n    // Remove any metadata before returning to the client\n    return payloads.map((payload) => PayloadHasher.jsonPayload(payload))\n  }\n\n  protected override async clearHandler(): Promise<void> {\n    await this.useDb((db) => db.clear(this.storeName))\n  }\n\n  protected override async deleteHandler(hashes: string[]): Promise<string[]> {\n    // Remove any duplicates\n    const distinctHashes = [...new Set(hashes)]\n    return await this.useDb(async (db) => {\n      // Only return hashes that were successfully deleted\n      const found = await Promise.all(\n        distinctHashes.map(async (hash) => {\n          // Check if the hash exists\n          const existing = await db.getKeyFromIndex(this.storeName, IndexedDbArchivist.hashIndexName, hash)\n          // If it does exist\n          if (existing) {\n            // Delete it\n            await db.delete(this.storeName, existing)\n            // Return the hash so it gets added to the list of deleted hashes\n            return hash\n          }\n        }),\n      )\n      return found.filter(exists)\n    })\n  }\n\n  protected override async getHandler(hashes: string[]): Promise<Payload[]> {\n    const payloads = await this.useDb((db) =>\n      Promise.all(hashes.map((hash) => db.getFromIndex(this.storeName, IndexedDbArchivist.hashIndexName, hash))),\n    )\n    return payloads.filter(exists)\n  }\n\n  protected override async insertHandler(payloads: Payload[]): Promise<Payload[]> {\n    const pairs = await PayloadHasher.hashPairs(payloads)\n    const db = await this.getInitializedDb()\n    try {\n      // Only return the payloads that were successfully inserted\n      const inserted = await Promise.all(\n        pairs.map(async ([payload, _hash]) => {\n          // Perform each insert via a transaction to ensure it is atomic\n          // with respect to checking for the pre-existence of the hash.\n          // This is done to preserve iteration via insertion order.\n          const tx = db.transaction(this.storeName, 'readwrite')\n          try {\n            // Get the object store\n            const store = tx.objectStore(this.storeName)\n            // Check if the hash already exists\n            const existing = await store.index(IndexedDbArchivist.hashIndexName).get(_hash)\n            // If it does not already exist\n            if (!existing) {\n              // Insert the payload\n              await store.put({ ...payload, _hash })\n              // Return it so it gets added to the list of inserted payloads\n              return payload\n            }\n          } finally {\n            // Close the transaction\n            await tx.done\n          }\n        }),\n      )\n      return inserted.filter(exists)\n    } finally {\n      db.close()\n    }\n  }\n\n  protected override async startHandler() {\n    await super.startHandler()\n    // NOTE: We could defer this creation to first access but we\n    // want to fail fast here in case something is wrong\n    await this.useDb(() => {})\n    return true\n  }\n\n  /**\n   * Returns that the desired DB/Store initialized to the correct version\n   * @returns The initialized DB\n   */\n  private async getInitializedDb(): Promise<IDBPDatabase<PayloadStore>> {\n    const { dbName, dbVersion, indexes, storeName } = this\n    const db = await openDB<PayloadStore>(dbName, dbVersion, {\n      blocked(currentVersion, blockedVersion, event) {\n        console.warn(`IndexedDbArchivist: Blocked from upgrading from ${currentVersion} to ${blockedVersion}`, event)\n      },\n      blocking(currentVersion, blockedVersion, event) {\n        console.warn(`IndexedDbArchivist: Blocking upgrade from ${currentVersion} to ${blockedVersion}`, event)\n      },\n      terminated() {\n        console.log('IndexedDbArchivist: Terminated')\n      },\n      upgrade(database, oldVersion, newVersion, transaction) {\n        // NOTE: This is called whenever the DB is created/updated. We could simply ensure the desired end\n        // state but, out of an abundance of caution, we will just delete (so we know where we are starting\n        // from a known good point) and recreate the desired state. This prioritizes resilience over data\n        // retention but we can revisit that tradeoff when it becomes limiting. Because distributed browser\n        // state is extremely hard to debug, this seems like fair tradeoff for now.\n        if (oldVersion !== newVersion) {\n          console.log(`IndexedDbArchivist: Upgrading from ${oldVersion} to ${newVersion}`)\n          // Delete any existing databases that are not the current version\n          const objectStores = transaction.objectStoreNames\n          for (const name of objectStores) {\n            try {\n              database.deleteObjectStore(name)\n            } catch {\n              console.log(`IndexedDbArchivist: Failed to delete existing object store ${name}`)\n            }\n          }\n        }\n        // Create the store\n        const store = database.createObjectStore(storeName, {\n          // If it isn't explicitly set, create a value by auto incrementing.\n          autoIncrement: true,\n        })\n        // Name the store\n        store.name = storeName\n        // Create an index on the hash\n        for (const { key, multiEntry, unique } of indexes) {\n          const indexKeys = Object.keys(key)\n          const keys = indexKeys.length === 1 ? indexKeys[0] : indexKeys\n          const indexName = buildStandardIndexName({ key, unique })\n          store.createIndex(indexName, keys, { multiEntry, unique })\n        }\n      },\n    })\n    return db\n  }\n\n  /**\n   * Executes a callback with the initialized DB and then closes the db\n   * @param callback The method to execute with the initialized DB\n   * @returns\n   */\n  private async useDb<T>(callback: (db: IDBPDatabase<PayloadStore>) => Promise<T> | T): Promise<T> {\n    // Get the initialized DB\n    const db = await this.getInitializedDb()\n    try {\n      // Perform the callback\n      return await callback(db)\n    } finally {\n      // Close the DB\n      db.close()\n    }\n  }\n}\n","export type IndexedDbArchivistSchema = 'network.xyo.archivist.indexeddb'\nexport const IndexedDbArchivistSchema: IndexedDbArchivistSchema = 'network.xyo.archivist.indexeddb'\n","import { ArchivistConfig, IndexDescription } from '@xyo-network/archivist-model'\n\nimport { IndexedDbArchivistSchema } from './Schema'\n\nexport type IndexedDbArchivistConfigSchema = `${IndexedDbArchivistSchema}.config`\nexport const IndexedDbArchivistConfigSchema: IndexedDbArchivistConfigSchema = `${IndexedDbArchivistSchema}.config`\n\nexport type IndexedDbArchivistConfig = ArchivistConfig<{\n  /**\n   * The database name\n   */\n  dbName?: string\n  /**\n   * The version of the DB, defaults to 1\n   */\n  dbVersion?: number\n  schema: IndexedDbArchivistConfigSchema\n  /**\n   * The storage configuration\n   * // TODO: Hoist to main archivist config\n   */\n  storage?: {\n    /**\n     * The indexes to create on the object store\n     */\n    indexes?: IndexDescription[]\n  }\n  /**\n   * The name of the object store\n   */\n  storeName?: string\n}>\n"],"mappings":"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","names":["exists","AbstractArchivist","ArchivistAllQuerySchema","ArchivistClearQuerySchema","ArchivistDeleteQuerySchema","ArchivistInsertQuerySchema","buildStandardIndexName","PayloadHasher","creatableModule","openDB","IndexedDbArchivistSchema","IndexedDbArchivistConfigSchema","IndexedDbArchivistSchema","IndexedDbArchivist","AbstractArchivist","dbName","config","name","defaultDbName","dbVersion","defaultDbVersion","queries","ArchivistAllQuerySchema","ArchivistClearQuerySchema","ArchivistDeleteQuerySchema","ArchivistInsertQuerySchema","storeName","defaultStoreName","indexes","hashIndex","schemaIndex","storage","allHandler","payloads","useDb","db","getAll","map","payload","PayloadHasher","jsonPayload","clearHandler","clear","deleteHandler","hashes","distinctHashes","Set","found","Promise","all","hash","existing","getKeyFromIndex","hashIndexName","delete","filter","exists","getHandler","getFromIndex","insertHandler","pairs","hashPairs","getInitializedDb","inserted","_hash","tx","transaction","store","objectStore","index","get","put","done","close","startHandler","openDB","blocked","currentVersion","blockedVersion","event","console","warn","blocking","terminated","log","upgrade","database","oldVersion","newVersion","objectStores","objectStoreNames","deleteObjectStore","createObjectStore","autoIncrement","key","multiEntry","unique","indexKeys","Object","keys","length","indexName","buildStandardIndexName","createIndex","callback","configSchemas","IndexedDbArchivistConfigSchema","schema","schemaIndexName","creatableModule"]}

package/package.json

@@ -10,21 +10,21 @@
     "url": "https://github.com/XYOracleNetwork/sdk-xyo-client-js/issues"
   },
   "dependencies": {
-    "@xylabs/assert": "^2.13.23",
     "@xylabs/exists": "^2.13.23",
-    "@xyo-network/archivist-abstract": "~2.87.1",
-    "@xyo-network/archivist-model": "~2.87.1",
-    "@xyo-network/hash": "~2.87.1",
-    "@xyo-network/module-model": "~2.87.1",
-    "@xyo-network/payload-model": "~2.87.1",
+    "@xyo-network/archivist-abstract": "~2.88.0",
+    "@xyo-network/archivist-model": "~2.88.0",
+    "@xyo-network/hash": "~2.88.0",
+    "@xyo-network/module-model": "~2.88.0",
+    "@xyo-network/payload-model": "~2.88.0",
     "idb": "^8.0.0"
   },
   "devDependencies": {
+    "@xylabs/assert": "^2.13.23",
     "@xylabs/ts-scripts-yarn3": "^3.2.41",
     "@xylabs/tsconfig": "^3.2.41",
-    "@xyo-network/account": "~2.87.1",
-    "@xyo-network/id-payload-plugin": "~2.87.1",
-    "@xyo-network/payload-wrapper": "~2.87.1",
+    "@xyo-network/account": "~2.88.0",
+    "@xyo-network/id-payload-plugin": "~2.88.0",
+    "@xyo-network/payload-wrapper": "~2.88.0",
     "fake-indexeddb": "^5.0.2",
     "typescript": "^5.3.3"
   },
@@ -67,6 +67,6 @@
     "url": "https://github.com/XYOracleNetwork/sdk-xyo-client-js.git"
   },
   "sideEffects": false,
-  "version": "2.87.1",
+  "version": "2.88.0",
   "type": "module"
 }

package/src/Archivist.ts

@@ -1,4 +1,3 @@
-import { assertEx } from '@xylabs/assert'
 import { exists } from '@xylabs/exists'
 import { AbstractArchivist } from '@xyo-network/archivist-abstract'
 import {
@@ -38,8 +37,6 @@ export class IndexedDbArchivist<
   // eslint-disable-next-line @typescript-eslint/member-ordering
   static readonly schemaIndexName = buildStandardIndexName(IndexedDbArchivist.schemaIndex)
 
-  private _db: IDBPDatabase<PayloadStore> | undefined
-
   /**
    * The database name. If not supplied via config, it defaults
    * to the module name (not guaranteed to be unique) and if module
@@ -70,75 +67,130 @@ export class IndexedDbArchivist<
     return this.config?.storeName ?? IndexedDbArchivist.defaultStoreName
   }
 
-  private get db(): IDBPDatabase<PayloadStore> {
-    return assertEx(this._db, 'DB not initialized')
-  }
-
+  /**
+   * The indexes to create on the store
+   */
   private get indexes() {
-    return this.config?.storage?.indexes ?? []
+    return [IndexedDbArchivist.hashIndex, IndexedDbArchivist.schemaIndex, ...(this.config?.storage?.indexes ?? [])]
   }
 
   protected override async allHandler(): Promise<Payload[]> {
     // Get all payloads from the store
-    const payloads = await this.db.getAll(this.storeName)
+    const payloads = await this.useDb((db) => db.getAll(this.storeName))
     // Remove any metadata before returning to the client
     return payloads.map((payload) => PayloadHasher.jsonPayload(payload))
   }
 
   protected override async clearHandler(): Promise<void> {
-    await this.db.clear(this.storeName)
+    await this.useDb((db) => db.clear(this.storeName))
   }
 
   protected override async deleteHandler(hashes: string[]): Promise<string[]> {
+    // Remove any duplicates
     const distinctHashes = [...new Set(hashes)]
-    const found = await Promise.all(
-      distinctHashes.map(async (hash) => {
-        let existing: IDBValidKey | undefined
-        do {
-          existing = await this.db.getKeyFromIndex(this.storeName, IndexedDbArchivist.hashIndexName, hash)
-          if (existing) await this.db.delete(this.storeName, existing)
-        } while (!existing)
-        return hash
-      }),
-    )
-    // Return hashes removed
-    return found.filter(exists)
+    return await this.useDb(async (db) => {
+      // Only return hashes that were successfully deleted
+      const found = await Promise.all(
+        distinctHashes.map(async (hash) => {
+          // Check if the hash exists
+          const existing = await db.getKeyFromIndex(this.storeName, IndexedDbArchivist.hashIndexName, hash)
+          // If it does exist
+          if (existing) {
+            // Delete it
+            await db.delete(this.storeName, existing)
+            // Return the hash so it gets added to the list of deleted hashes
+            return hash
+          }
+        }),
+      )
+      return found.filter(exists)
+    })
   }
 
   protected override async getHandler(hashes: string[]): Promise<Payload[]> {
-    const payloads = await Promise.all(hashes.map((hash) => this.db.getFromIndex(this.storeName, IndexedDbArchivist.hashIndexName, hash)))
+    const payloads = await this.useDb((db) =>
+      Promise.all(hashes.map((hash) => db.getFromIndex(this.storeName, IndexedDbArchivist.hashIndexName, hash))),
+    )
     return payloads.filter(exists)
   }
 
   protected override async insertHandler(payloads: Payload[]): Promise<Payload[]> {
     const pairs = await PayloadHasher.hashPairs(payloads)
-    // Only return the payloads that were successfully inserted
-    const inserted = await Promise.all(
-      pairs.map(async ([payload, _hash]) => {
-        const tx = this.db.transaction(this.storeName, 'readwrite')
-        try {
-          const store = tx.objectStore(this.storeName)
-          const existing = await store.index(IndexedDbArchivist.hashIndexName).get(_hash)
-          if (!existing) {
-            await store.put({ ...payload, _hash })
-            return payload
+    const db = await this.getInitializedDb()
+    try {
+      // Only return the payloads that were successfully inserted
+      const inserted = await Promise.all(
+        pairs.map(async ([payload, _hash]) => {
+          // Perform each insert via a transaction to ensure it is atomic
+          // with respect to checking for the pre-existence of the hash.
+          // This is done to preserve iteration via insertion order.
+          const tx = db.transaction(this.storeName, 'readwrite')
+          try {
+            // Get the object store
+            const store = tx.objectStore(this.storeName)
+            // Check if the hash already exists
+            const existing = await store.index(IndexedDbArchivist.hashIndexName).get(_hash)
+            // If it does not already exist
+            if (!existing) {
+              // Insert the payload
+              await store.put({ ...payload, _hash })
+              // Return it so it gets added to the list of inserted payloads
+              return payload
+            }
+          } finally {
+            // Close the transaction
+            await tx.done
           }
-        } finally {
-          await tx.done
-        }
-      }),
-    )
-    return inserted.filter(exists)
+        }),
+      )
+      return inserted.filter(exists)
+    } finally {
+      db.close()
+    }
   }
 
   protected override async startHandler() {
     await super.startHandler()
     // NOTE: We could defer this creation to first access but we
     // want to fail fast here in case something is wrong
+    await this.useDb(() => {})
+    return true
+  }
+
+  /**
+   * Returns that the desired DB/Store initialized to the correct version
+   * @returns The initialized DB
+   */
+  private async getInitializedDb(): Promise<IDBPDatabase<PayloadStore>> {
     const { dbName, dbVersion, indexes, storeName } = this
-    this._db = await openDB<PayloadStore>(dbName, dbVersion, {
-      async upgrade(database) {
-        await Promise.resolve() // Async to match spec
+    const db = await openDB<PayloadStore>(dbName, dbVersion, {
+      blocked(currentVersion, blockedVersion, event) {
+        console.warn(`IndexedDbArchivist: Blocked from upgrading from ${currentVersion} to ${blockedVersion}`, event)
+      },
+      blocking(currentVersion, blockedVersion, event) {
+        console.warn(`IndexedDbArchivist: Blocking upgrade from ${currentVersion} to ${blockedVersion}`, event)
+      },
+      terminated() {
+        console.log('IndexedDbArchivist: Terminated')
+      },
+      upgrade(database, oldVersion, newVersion, transaction) {
+        // NOTE: This is called whenever the DB is created/updated. We could simply ensure the desired end
+        // state but, out of an abundance of caution, we will just delete (so we know where we are starting
+        // from a known good point) and recreate the desired state. This prioritizes resilience over data
+        // retention but we can revisit that tradeoff when it becomes limiting. Because distributed browser
+        // state is extremely hard to debug, this seems like fair tradeoff for now.
+        if (oldVersion !== newVersion) {
+          console.log(`IndexedDbArchivist: Upgrading from ${oldVersion} to ${newVersion}`)
+          // Delete any existing databases that are not the current version
+          const objectStores = transaction.objectStoreNames
+          for (const name of objectStores) {
+            try {
+              database.deleteObjectStore(name)
+            } catch {
+              console.log(`IndexedDbArchivist: Failed to delete existing object store ${name}`)
+            }
+          }
+        }
         // Create the store
         const store = database.createObjectStore(storeName, {
           // If it isn't explicitly set, create a value by auto incrementing.
@@ -147,8 +199,7 @@ export class IndexedDbArchivist<
         // Name the store
         store.name = storeName
         // Create an index on the hash
-        const indexesToCreate = [IndexedDbArchivist.hashIndex, IndexedDbArchivist.schemaIndex, ...indexes]
-        for (const { key, multiEntry, unique } of indexesToCreate) {
+        for (const { key, multiEntry, unique } of indexes) {
           const indexKeys = Object.keys(key)
           const keys = indexKeys.length === 1 ? indexKeys[0] : indexKeys
           const indexName = buildStandardIndexName({ key, unique })
@@ -156,6 +207,23 @@ export class IndexedDbArchivist<
         }
       },
     })
-    return true
+    return db
+  }
+
+  /**
+   * Executes a callback with the initialized DB and then closes the db
+   * @param callback The method to execute with the initialized DB
+   * @returns
+   */
+  private async useDb<T>(callback: (db: IDBPDatabase<PayloadStore>) => Promise<T> | T): Promise<T> {
+    // Get the initialized DB
+    const db = await this.getInitializedDb()
+    try {
+      // Perform the callback
+      return await callback(db)
+    } finally {
+      // Close the DB
+      db.close()
+    }
   }
 }