@xyo-network/diviner-payload-indexeddb 2.87.2 → 2.88.0

package/src/Diviner.ts

@@ -71,58 +71,59 @@ export class IndexedDbPayloadDiviner<
   protected override async divineHandler(payloads?: TIn[]): Promise<TOut[]> {
     const query = payloads?.filter(isPayloadDivinerQueryPayload)?.pop()
     if (!query) return []
-    const db = await this.tryGetInitializedDb()
-    if (!db) return []
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const { schemas, limit, offset, hash, order, schema: _schema, sources, ...props } = query as unknown as TIn & { sources?: string[] }
-    const tx = db.transaction(this.storeName, 'readonly')
-    const store = tx.objectStore(this.storeName)
-    const results: TOut[] = []
-    let parsedOffset = offset ?? 0
-    const parsedLimit = limit ?? 10
-    assertEx((schemas?.length ?? 1) === 1, 'IndexedDbPayloadDiviner: Only one filter schema supported')
-    const filterSchema = schemas?.[0]
-    const filter = filterSchema ? { schema: filterSchema, ...props } : { ...props }
-    const direction: IDBCursorDirection = order === 'desc' ? 'prev' : 'next'
-    const suggestedIndex = this.selectBestIndex(filter, store)
-    const keyRangeValue = this.getKeyRangeValue(suggestedIndex, filter)
-    const valueFilters: ValueFilter[] = props
-      ? Object.entries(props)
-          .map(([key, value]) => payloadValueFilter(key, value))
-          .filter(exists)
-      : []
-    let cursor = suggestedIndex
-      ? // Conditionally filter on schemas
-        await store.index(suggestedIndex).openCursor(IDBKeyRange.only(keyRangeValue), direction)
-      : // Just iterate all records
-        await store.openCursor(suggestedIndex, direction)
-
-    // Skip records until the offset is reached
-    while (cursor && parsedOffset > 0) {
-      cursor = await cursor.advance(parsedOffset)
-      parsedOffset = 0 // Reset offset after skipping
-    }
-    // Collect results up to the limit
-    while (cursor && results.length < parsedLimit) {
-      const value = cursor.value
-      if (value) {
-        // If we're filtering on more than just the schema
-        if (valueFilters.length > 0) {
-          // Ensure all filters pass
-          if (valueFilters.every((filter) => filter(value))) {
-            // Then save the value
+    const result = await this.tryUseDb(async (db) => {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { schemas, limit, offset, hash, order, schema: _schema, sources, ...props } = query as unknown as TIn & { sources?: string[] }
+      const tx = db.transaction(this.storeName, 'readonly')
+      const store = tx.objectStore(this.storeName)
+      const results: TOut[] = []
+      let parsedOffset = offset ?? 0
+      const parsedLimit = limit ?? 10
+      assertEx((schemas?.length ?? 1) === 1, 'IndexedDbPayloadDiviner: Only one filter schema supported')
+      const filterSchema = schemas?.[0]
+      const filter = filterSchema ? { schema: filterSchema, ...props } : { ...props }
+      const direction: IDBCursorDirection = order === 'desc' ? 'prev' : 'next'
+      const suggestedIndex = this.selectBestIndex(filter, store)
+      const keyRangeValue = this.getKeyRangeValue(suggestedIndex, filter)
+      const valueFilters: ValueFilter[] = props
+        ? Object.entries(props)
+            .map(([key, value]) => payloadValueFilter(key, value))
+            .filter(exists)
+        : []
+      let cursor = suggestedIndex
+        ? // Conditionally filter on schemas
+          await store.index(suggestedIndex).openCursor(IDBKeyRange.only(keyRangeValue), direction)
+        : // Just iterate all records
+          await store.openCursor(suggestedIndex, direction)
+
+      // Skip records until the offset is reached
+      while (cursor && parsedOffset > 0) {
+        cursor = await cursor.advance(parsedOffset)
+        parsedOffset = 0 // Reset offset after skipping
+      }
+      // Collect results up to the limit
+      while (cursor && results.length < parsedLimit) {
+        const value = cursor.value
+        if (value) {
+          // If we're filtering on more than just the schema
+          if (valueFilters.length > 0) {
+            // Ensure all filters pass
+            if (valueFilters.every((filter) => filter(value))) {
+              // Then save the value
+              results.push(value)
+            }
+          } else {
+            // Otherwise just save the value
             results.push(value)
           }
-        } else {
-          // Otherwise just save the value
-          results.push(value)
         }
+        cursor = await cursor.continue()
       }
-      cursor = await cursor.continue()
-    }
-    await tx.done
-    // Remove any metadata before returning to the client
-    return results.map((payload) => PayloadHasher.jsonPayload(payload))
+      await tx.done
+      // Remove any metadata before returning to the client
+      return results.map((payload) => PayloadHasher.jsonPayload(payload))
+    })
+    return result ?? []
   }
 
   protected override async startHandler() {
@@ -177,27 +178,50 @@ export class IndexedDbPayloadDiviner<
   }
 
   /**
-   * Checks that the desired DB/Store exists and is initialized
-   * @returns The initialized DB or undefined if it does not exist
+   * Checks that the desired DB/objectStore exists and is initialized to the correct version
+   * @returns The initialized DB or undefined if it does not exist in the desired state
    */
   private async tryGetInitializedDb(): Promise<IDBPDatabase<PayloadStore> | undefined> {
-    // If we've already checked and found a successfully initialized
-    // db and objectStore, return the cached value
-    if (this._db) return this._db
     // Enumerate the DBs
     const dbs = await indexedDB.databases()
+    // Check that the DB exists at the desired version
     const dbExists = dbs.some((db) => {
-      // Check for the desired name/version
       return db.name === this.dbName && db.version === this.dbVersion
     })
-    // If the DB does not exist at the desired version, return undefined
-    if (!dbExists) return
-    // If the db does exist, open it
-    const db = await openDB<PayloadStore>(this.dbName, this.dbVersion)
-    // Check that the desired objectStore exists
-    const storeExists = db.objectStoreNames.contains(this.storeName)
-    // If the correct db/store exists, cache it for future calls
-    if (storeExists) this._db = db
-    return this._db
+    // If the DB exists at the desired version
+    if (dbExists) {
+      // If the db does exist, open it
+      const db = await openDB<PayloadStore>(this.dbName, this.dbVersion)
+      // Check that the desired objectStore exists
+      const storeExists = db.objectStoreNames.contains(this.storeName)
+      // If the correct db/version/objectStore exists
+      if (storeExists) {
+        return db
+      } else {
+        // Otherwise close the db so the process that is going to update the
+        // db can open it
+        db.close()
+      }
+    }
+  }
+
+  /**
+   * 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 tryUseDb<T>(callback: (db: IDBPDatabase<PayloadStore>) => Promise<T> | T): Promise<T | undefined> {
+    // Get the initialized DB
+    const db = await this.tryGetInitializedDb()
+    if (db) {
+      try {
+        // Perform the callback
+        return await callback(db)
+      } finally {
+        // Close the DB
+        db.close()
+      }
+    }
+    return undefined
   }
 }