@xyo-network/archivist-lmdb 5.1.22 → 5.1.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/archivist-lmdb",
-  "version": "5.1.22",
+  "version": "5.1.23",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -30,36 +30,39 @@
   "types": "dist/browser/index.d.ts",
   "files": [
     "dist",
-    "src"
+    "src",
+    "!**/*.bench.*",
+    "!**/*.spec.*",
+    "!**/*.test.*"
   ],
   "dependencies": {
-    "@xylabs/assert": "~5.0.24",
-    "@xylabs/exists": "~5.0.24",
-    "@xylabs/hex": "~5.0.24",
-    "@xylabs/promise": "~5.0.24",
-    "@xyo-network/archivist-abstract": "~5.1.22",
-    "@xyo-network/archivist-model": "~5.1.22",
-    "@xyo-network/boundwitness-model": "~5.1.22",
-    "@xyo-network/module-model": "~5.1.22",
-    "@xyo-network/payload-builder": "~5.1.22",
-    "@xyo-network/payload-model": "~5.1.22",
+    "@xylabs/assert": "~5.0.33",
+    "@xylabs/exists": "~5.0.33",
+    "@xylabs/hex": "~5.0.33",
+    "@xylabs/promise": "~5.0.33",
+    "@xyo-network/archivist-abstract": "~5.1.23",
+    "@xyo-network/archivist-model": "~5.1.23",
+    "@xyo-network/boundwitness-model": "~5.1.23",
+    "@xyo-network/module-model": "~5.1.23",
+    "@xyo-network/payload-builder": "~5.1.23",
+    "@xyo-network/payload-model": "~5.1.23",
     "lmdb": "~3.4.4"
   },
   "devDependencies": {
-    "@xylabs/delay": "~5.0.24",
-    "@xylabs/object": "~5.0.24",
+    "@xylabs/delay": "~5.0.33",
+    "@xylabs/object": "~5.0.33",
     "@xylabs/ts-scripts-yarn3": "~7.2.8",
     "@xylabs/tsconfig": "~7.2.8",
-    "@xylabs/vitest-extended": "~5.0.24",
-    "@xyo-network/account": "~5.1.22",
-    "@xyo-network/account-model": "~5.1.22",
-    "@xyo-network/archivist-acceptance-tests": "~5.1.22",
-    "@xyo-network/id-payload-plugin": "~5.1.22",
-    "@xyo-network/payload-wrapper": "~5.1.22",
-    "@xyo-network/wallet": "~5.1.22",
+    "@xylabs/vitest-extended": "~5.0.33",
+    "@xyo-network/account": "~5.1.23",
+    "@xyo-network/account-model": "~5.1.23",
+    "@xyo-network/archivist-acceptance-tests": "~5.1.23",
+    "@xyo-network/id-payload-plugin": "~5.1.23",
+    "@xyo-network/payload-wrapper": "~5.1.23",
+    "@xyo-network/wallet": "~5.1.23",
     "typescript": "~5.9.3",
     "uuid": "~13.0.0",
-    "vitest": "~4.0.8"
+    "vitest": "~4.0.9"
   },
   "publishConfig": {
     "access": "public"

package/dist/browser/spec/Archivist.full.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Archivist.full.spec.d.ts.map

package/dist/browser/spec/Archivist.full.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Archivist.full.spec.d.ts","sourceRoot":"","sources":["../../../src/spec/Archivist.full.spec.ts"],"names":[],"mappings":""}

package/dist/browser/spec/Archivist.spec.d.ts

@@ -1,2 +0,0 @@
-import '@xylabs/vitest-extended';
-//# sourceMappingURL=Archivist.spec.d.ts.map

package/dist/browser/spec/Archivist.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Archivist.spec.d.ts","sourceRoot":"","sources":["../../../src/spec/Archivist.spec.ts"],"names":[],"mappings":"AACA,OAAO,yBAAyB,CAAA"}

package/src/spec/Archivist.full.spec.ts

@@ -1,427 +0,0 @@
-/* eslint-disable complexity */
-/* eslint-disable max-statements */
-
-import { tmpdir } from 'node:os'
-
-import { delay } from '@xylabs/delay'
-import type { Hash } from '@xylabs/hex'
-import type { AnyObject } from '@xylabs/object'
-import { Account } from '@xyo-network/account'
-import type { AccountInstance } from '@xyo-network/account-model'
-import { generateArchivistNextTests } from '@xyo-network/archivist-acceptance-tests'
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import { isArchivistInstance, isArchivistModule } from '@xyo-network/archivist-model'
-import { IdSchema } from '@xyo-network/id-payload-plugin'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { Payload, WithStorageMeta } from '@xyo-network/payload-model'
-import { PayloadWrapper } from '@xyo-network/payload-wrapper'
-import { v4 } from 'uuid'
-import {
-  beforeAll, describe, expect, it,
-} from 'vitest'
-
-import { LmdbArchivist } from '../Archivist.ts'
-import { LmdbArchivistConfigSchema } from '../Config.ts'
-
-/**
- * @group module
- * @group archivist
- */
-describe('LmdbArchivist [full]', () => {
-  type TestPayload = Payload<{ salt: string; schema: string }>
-
-  const fillDb = async (db: ArchivistInstance, count: number = 10): Promise<TestPayload[]> => {
-    const sources = Array.from({ length: count }).map((_, i) => {
-      return { salt: `${i}`, schema: IdSchema }
-    })
-    for (const source of sources) {
-      await db.insert([source])
-    }
-    return sources
-  }
-
-  const shuffleArray = <T>(original: Array<T>) => {
-    const shuffled = [...original]
-    for (let i = shuffled.length - 1; i > 0; i--) {
-      // Generate a random index between 0 and i
-      const j = Math.floor(Math.random() * (i + 1))
-      // Swap elements at indices i and j
-      ;[shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]]
-    }
-    return shuffled
-  }
-  let account: AccountInstance
-  beforeAll(async () => {
-    account = await Account.random()
-  })
-  describe('config', () => {
-    describe('dbName', () => {
-      it('supplied via config uses config value', async () => {
-        const dbName = 'testDbName'
-        const archivist = await LmdbArchivist.create({
-          account,
-          config: {
-            dbName, schema: LmdbArchivistConfigSchema, storeName: 'payloads', location: tmpdir(), clearStoreOnStart: true,
-          },
-        })
-        expect(archivist.dbName).toBe(dbName)
-      })
-    })
-    describe('dbStore', () => {
-      it('supplied via config uses config value', async () => {
-        const dbName = 'testDbName'
-        const storeName = 'testStoreName'
-        const archivist = await LmdbArchivist.create({
-          account,
-          config: {
-            dbName, schema: LmdbArchivistConfigSchema, storeName, location: tmpdir(), clearStoreOnStart: true,
-          },
-        })
-        expect(archivist.storeName).toBe(storeName)
-      })
-      it('allows for multiple dbStores within the same dbName', async () => {
-        const dbName = 'testDbName'
-        const storeName1 = 'testStoreName1'
-        const storeName2 = 'testStoreName2'
-        const archivist1 = await LmdbArchivist.create({
-          account,
-          config: {
-            dbName, schema: LmdbArchivistConfigSchema, storeName: storeName1, location: tmpdir(), clearStoreOnStart: true,
-          },
-        })
-        const archivist2 = await LmdbArchivist.create({
-          account,
-          config: {
-            dbName, schema: LmdbArchivistConfigSchema, storeName: storeName2, location: tmpdir(), clearStoreOnStart: true,
-          },
-        })
-
-        expect(isArchivistInstance(archivist1)).toBeTruthy()
-        expect(isArchivistModule(archivist1)).toBeTruthy()
-
-        // TODO: This test is not testing the end state of indexedDB, but rather the
-        // state of the Archivist instance and therefore isn't valid.  We'd want to actually
-        // open indexedDB and check the state of the stores matches what we want (which it doesn't).
-        expect(archivist1.storeName).toBe(storeName1)
-        expect(archivist2.storeName).toBe(storeName2)
-      })
-    })
-  })
-  describe('all', () => {
-    const dbName = 'e926a178-9c6a-4604-b65c-d1fccd97f1de'
-    const storeName = '27fcea19-c30f-415a-a7f9-0b0514705cb1'
-    let sources: Payload[] = []
-    let archivistModule: ArchivistInstance
-    beforeAll(async () => {
-      archivistModule = await LmdbArchivist.create({
-        account,
-        config: {
-          dbName, schema: LmdbArchivistConfigSchema, storeName, location: tmpdir(), clearStoreOnStart: true,
-        },
-      })
-      sources = await fillDb(archivistModule)
-    })
-    it('returns all data', async () => {
-      const getResult = await archivistModule.all?.()
-      expect(getResult).toBeDefined()
-      expect(getResult?.length).toBe(sources.length)
-      expect(PayloadBuilder.omitStorageMeta(getResult)).toEqual(sources)
-    })
-  })
-
-  describe('delete', () => {
-    const dbName = '6e3fcd65-f24f-4ebc-b314-f597b385fb8e'
-    const storeName = 'c0872f52-32b9-415e-8ca9-af78713cee28'
-    let sources: Payload[] = []
-    let archivistModule: ArchivistInstance
-    beforeAll(async () => {
-      archivistModule = await LmdbArchivist.create({
-        account,
-        config: {
-          dbName, schema: LmdbArchivistConfigSchema, storeName, location: tmpdir(), clearStoreOnStart: true,
-        },
-      })
-      sources = await fillDb(archivistModule)
-    })
-    it('deletes data', async () => {
-      const getResult = (await archivistModule.all?.()) ?? []
-      expect(getResult).toBeDefined()
-      expect(getResult?.length).toBe(sources.length)
-      const dataHashes = (await PayloadBuilder.dataHashes(getResult)) ?? []
-      const deleteResult = await archivistModule.delete?.(dataHashes)
-      expect(deleteResult.length).toBe(dataHashes.length)
-      expect((await archivistModule.all?.()).length).toBe(0)
-    })
-  })
-  describe('get', () => {
-    const dbName = 'b4379714-73d1-42c6-88e7-1a363b7ed86f'
-    const storeName = '3dbdb153-79d0-45d0-b2f7-9f06cdd74b1e'
-    let sources: TestPayload[] = []
-    let archivistModule: ArchivistInstance
-    beforeAll(async () => {
-      archivistModule = await LmdbArchivist.create({
-        account,
-        config: {
-          dbName, schema: LmdbArchivistConfigSchema, storeName, location: tmpdir(), clearStoreOnStart: true,
-        },
-      })
-      sources = await fillDb(archivistModule)
-    })
-    it('gets existing data', async () => {
-      for (const source of sources) {
-        const sourceHash = await PayloadBuilder.dataHash(source)
-        const getResult = await archivistModule.get([sourceHash])
-        expect(getResult).toBeDefined()
-        expect(getResult.length).toBe(1)
-        const resultHash = await PayloadWrapper.wrap(getResult[0]).dataHash()
-        expect(resultHash).toBe(sourceHash)
-      }
-    })
-    it('returned by order of insertion', async () => {
-      const shuffled = shuffleArray(sources)
-      const sourceHashes = await Promise.all(shuffled.map(source => PayloadBuilder.dataHash(source)))
-      const getResult = (await archivistModule.get(sourceHashes)) as WithStorageMeta<TestPayload>[]
-      expect(getResult).toBeDefined()
-      expect(getResult.length).toBe(sourceHashes.length)
-      const salts = sources.map(source => source.salt)
-      const resultSalts = getResult.map(result => result?.salt)
-      expect(resultSalts).toEqual(salts)
-    })
-    it('returns nothing for non-existing hashes', async () => {
-      const hashThatDoesNotExist = '0000000000000000000000000000000000000000000000000000000000000000' as Hash
-      const getResult = await archivistModule.get([hashThatDoesNotExist])
-      expect(getResult).toBeDefined()
-      expect(getResult.length).toBe(0)
-    })
-    describe('by hash', () => {
-      let payload1: Payload<AnyObject>
-      let payload2: Payload<AnyObject>
-      let dataHash1: Hash
-      let dataHash2: Hash
-      let rootHash1: Hash
-      let rootHash2: Hash
-      beforeAll(async () => {
-        const salt = '650123f6-191e-4cc4-a813-f7a29dcbfb0e'
-        payload1 = {
-          $some: [
-            '12bed6aa884f5b7ffc08e19790b5db0da724b8b7471138dcbec090a0798861db0da8255f0d9297ba981b2cbbea65d9eadabac6632124f10f22c709d333a1f285',
-          ],
-          salt,
-          schema: IdSchema,
-        }
-        payload2 = {
-          $some: [
-            '22bed6aa884f5b7ffc08e19790b5db0da724b8b7471138dcbec090a0798861db0da8255f0d9297ba981b2cbbea65d9eadabac6632124f10f22c709d333a1f285',
-          ],
-          salt,
-          schema: IdSchema,
-        }
-        dataHash1 = await PayloadBuilder.dataHash(payload1)
-        dataHash2 = await PayloadBuilder.dataHash(payload2)
-        rootHash1 = await PayloadBuilder.hash(payload1)
-        rootHash2 = await PayloadBuilder.hash(payload2)
-        expect(dataHash1).toBe(dataHash2)
-        expect(rootHash1).not.toBe(rootHash2)
-        await archivistModule.insert([payload1])
-        await archivistModule.insert([payload2])
-      })
-      describe('data hash', () => {
-        it('returns value using hash', async () => {
-          const result = await archivistModule.get([dataHash1])
-          expect(result).toBeDefined()
-          expect(result.length).toBe(1)
-        })
-        it('deduplicates multiple hashes', async () => {
-          const result = await archivistModule.get([dataHash1, dataHash2])
-          expect(result).toBeDefined()
-          expect(result.length).toBe(1)
-        })
-        it('returns the first occurrence of the hash', async () => {
-          // Same data hash contained by multiple root hashes
-          const result = await archivistModule.get([dataHash2])
-          expect(result).toBeDefined()
-          expect(result.length).toBe(1)
-          // Returns the first occurrence of the data hash
-          // expect(PayloadBuilder.omitStorageMeta(result[0])).toEqual(payload1)
-        })
-      })
-      describe('root hash', () => {
-        it('returns value using hash', async () => {
-          const result = await archivistModule.get([rootHash1])
-          expect(result).toBeDefined()
-          expect(result.length).toBe(1)
-        })
-        it('deduplicates multiple hashes', async () => {
-          const result = await archivistModule.get([rootHash1, rootHash1])
-          expect(result).toBeDefined()
-          expect(result.length).toBe(1)
-        })
-      })
-    })
-  })
-  describe('insert', () => {
-    describe('with unique data', () => {
-      const dbName = 'bd86d2dd-dc48-4621-8c1f-105ba2e90287'
-      const storeName = 'f8d14049-2966-4198-a2ab-1c096a949315'
-      let sources: Payload[] = []
-      let archivistModule: ArchivistInstance
-      beforeAll(async () => {
-        archivistModule = await LmdbArchivist.create({
-          account,
-          config: {
-            dbName, schema: LmdbArchivistConfigSchema, storeName, location: tmpdir(), clearStoreOnStart: true,
-          },
-        })
-        sources = await fillDb(archivistModule)
-      })
-      it('can round trip data using data hash', async () => {
-        await Promise.all(
-          sources.map(async (source) => {
-            const sourceHash = await PayloadBuilder.dataHash(source)
-            const getResult = await archivistModule.get([sourceHash])
-            expect(getResult).toBeDefined()
-            expect(getResult.length).toBe(1)
-            const [result] = getResult
-            expect(PayloadBuilder.omitStorageMeta(result)).toEqual(PayloadBuilder.omitStorageMeta(source))
-            const resultHash = await PayloadBuilder.dataHash(result)
-            expect(resultHash).toBe(sourceHash)
-          }),
-        )
-      })
-      it('can round trip data using root hash', async () => {
-        await Promise.all(
-          sources.map(async (source) => {
-            const sourceHash = await PayloadBuilder.hash(source)
-            const getResult = await archivistModule.get([sourceHash])
-            expect(getResult).toBeDefined()
-            expect(getResult.length).toBe(1)
-            const [result] = getResult
-            expect(PayloadBuilder.omitStorageMeta(result)).toEqual(PayloadBuilder.omitStorageMeta(source))
-            const resultHash = await PayloadBuilder.hash(result)
-            expect(resultHash).toBe(sourceHash)
-          }),
-        )
-      })
-    })
-    describe('with duplicate data', () => {
-      const dbName = 'bb43b6fe-2f9e-4bda-8177-f94336353f98'
-      const storeName = '91c6b87d-3ac8-4cfd-8aee-d509f3de0299'
-      let archivistModule: ArchivistInstance
-      beforeAll(async () => {
-        archivistModule = await LmdbArchivist.create({
-          account,
-          config: {
-            dbName, schema: LmdbArchivistConfigSchema, storeName, location: tmpdir(), clearStoreOnStart: true,
-          },
-        })
-      })
-      it('handles duplicate insertions', async () => {
-        // Insert same payload twice
-        const source = { salt: '2d515e1d-d82c-4545-9903-3eded7fefa7c', schema: IdSchema }
-        // First insertion should succeed and return the inserted payload
-        expect((await archivistModule.insert([source]))[0]._hash).toEqual(await PayloadBuilder.hash(source))
-        // Second insertion should succeed but return empty array since no new data was inserted
-        expect(await archivistModule.insert([source])).toEqual([])
-        // Ensure we can get the inserted payload
-        const sourceHash = await PayloadBuilder.dataHash(source)
-        const getResult = await archivistModule.get([sourceHash])
-        expect(getResult).toBeDefined()
-        expect(getResult.length).toBe(1)
-        const resultHash = await PayloadBuilder.dataHash(getResult[0])
-        expect(resultHash).toBe(sourceHash)
-        // Ensure the DB has only one instance of the payload written to it
-        const allResult = await archivistModule.all?.()
-        expect(allResult).toBeDefined()
-        expect(allResult.length).toBe(1)
-      })
-    })
-  })
-
-  describe('next', () => {
-    const dbName = 'bd86d2dd-dc48-4621-8c1f-105ba2e90288'
-    const storeName = 'f8d14049-2966-4198-a2ab-1c096a949316'
-    it('next', async () => {
-      const archivist = await LmdbArchivist.create({
-        account: 'random',
-        config: {
-          dbName, schema: LmdbArchivistConfigSchema, storeName, location: tmpdir(), clearStoreOnStart: true,
-        },
-      })
-      const account = await Account.random()
-
-      const payloads1 = [
-        { schema: 'network.xyo.test', value: 1 },
-      ]
-
-      const payloads2 = [
-        { schema: 'network.xyo.test', value: 2 },
-      ]
-
-      const payloads3 = [
-        { schema: 'network.xyo.test', value: 3 },
-      ]
-
-      const payloads4 = [
-        { schema: 'network.xyo.test', value: 4 },
-      ]
-
-      await archivist.insert(payloads1)
-      await delay(1)
-      const [bw, payloads, errors] = await archivist.insertQuery(payloads2, account)
-      await delay(1)
-      await archivist.insert(payloads3)
-      await delay(1)
-      await archivist.insert(payloads4)
-      await delay(1)
-      expect(bw).toBeDefined()
-      expect(payloads).toBeDefined()
-      expect(errors).toBeDefined()
-
-      const batch1 = await archivist.next?.({ limit: 2 })
-      expect(batch1.length).toBe(2)
-      expect(await PayloadBuilder.dataHash(batch1?.[0])).toEqual(await PayloadBuilder.dataHash(payloads1[0]))
-
-      const batch2 = await archivist.next?.({ limit: 2, cursor: batch1?.[1]._sequence })
-      expect(batch2.length).toBe(2)
-      expect(await PayloadBuilder.dataHash(batch2?.[1])).toEqual(await PayloadBuilder.dataHash(payloads4[0]))
-
-      const batch3 = await archivist.next?.({ limit: 20 })
-      expect(batch3.length).toBe(4)
-      expect(await PayloadBuilder.dataHash(batch3?.[0])).toEqual(await PayloadBuilder.dataHash(payloads1[0]))
-
-      const batch4 = await archivist.next?.({ limit: 20, cursor: batch1?.[0]._sequence })
-      expect(batch4.length).toBe(3)
-      expect(await PayloadBuilder.dataHash(batch4?.[0])).toEqual(await PayloadBuilder.dataHash(payloads2[0]))
-
-      // desc
-      const batch1Desc = await archivist.next?.({ limit: 2, order: 'desc' })
-      expect(batch1Desc.length).toBe(2)
-      expect(await PayloadBuilder.dataHash(batch1Desc?.[0])).toEqual(await PayloadBuilder.dataHash(payloads4[0]))
-
-      const batch2Desc = await archivist.next?.({
-        limit: 2, cursor: batch1Desc?.[1]._sequence, order: 'desc',
-      })
-      expect(batch2Desc.length).toBe(2)
-      expect(await PayloadBuilder.dataHash(batch2Desc?.[1])).toEqual(await PayloadBuilder.dataHash(payloads1[0]))
-
-      const batch3Desc = await archivist.next?.({
-        limit: 20, cursor: batch1Desc?.[1]._sequence, order: 'desc',
-      })
-      expect(batch3Desc.length).toBe(2)
-      expect(await PayloadBuilder.dataHash(batch3Desc?.[1])).toEqual(await PayloadBuilder.dataHash(payloads1[0]))
-    })
-  })
-  generateArchivistNextTests(async () => {
-    const dbName = v4()
-    const storeName = v4()
-    const location = tmpdir()
-    const clearStoreOnStart = true
-    const schema = LmdbArchivistConfigSchema
-    return await LmdbArchivist.create({
-      account: 'random',
-      config: {
-        dbName, schema, storeName, location, clearStoreOnStart,
-      },
-    })
-  })
-})

package/src/spec/Archivist.spec.ts

@@ -1,163 +0,0 @@
-/* eslint-disable max-statements */
-import '@xylabs/vitest-extended'
-
-import { tmpdir } from 'node:os'
-
-import { delay } from '@xylabs/delay'
-import { toSafeJsonString } from '@xylabs/object'
-import { isArchivistInstance, isArchivistModule } from '@xyo-network/archivist-model'
-import type { Id } from '@xyo-network/id-payload-plugin'
-import {
-  asId,
-  IdSchema, isId,
-} from '@xyo-network/id-payload-plugin'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import { HDWallet } from '@xyo-network/wallet'
-import {
-  describe, expect, it,
-} from 'vitest'
-
-import { LmdbArchivist } from '../Archivist.ts'
-import { LmdbArchivistConfigSchema } from '../Config.ts'
-
-/**
- * @group module
- * @group archivist
- */
-describe('LmdbArchivist', () => {
-  it('should listen to cleared events', async () => {
-    const archivist = await LmdbArchivist.create({
-      account: 'random',
-      config: {
-        schema: LmdbArchivistConfigSchema, location: tmpdir(), dbName: 'test1.db', storeName: 'payloads', clearStoreOnStart: true,
-      },
-    })
-
-    expect(isArchivistInstance(archivist)).toBe(true)
-    expect(isArchivistModule(archivist)).toBe(true)
-
-    // Create a new promise and resolve it when the event fires
-    const eventPromise = new Promise<void>((resolve) => {
-      archivist.on('cleared', () => {
-        expect(true).toBe(true) // Confirm event fired
-        resolve() // Resolve the promise
-      })
-    })
-    await archivist.clear()
-    return eventPromise
-  })
-
-  it('should return items inserted in the order they were provided in', async () => {
-    const archivist = await LmdbArchivist.create({
-      account: 'random',
-      config: {
-        schema: LmdbArchivistConfigSchema, location: tmpdir(), dbName: 'test2.db', storeName: 'payloads', clearStoreOnStart: true,
-      },
-    })
-    const payloads: Id[] = Array.from({ length: 100 }, (_, i) => new PayloadBuilder<Id>({ schema: IdSchema }).fields({ salt: `${i}` }).build())
-    // Ensure payload was create in order provided
-    for (const [index, id] of payloads.entries()) {
-      expect(id?.salt).toBe(`${index}`)
-    }
-
-    const withStorageMeta = await PayloadBuilder.addStorageMeta(payloads)
-
-    // Ensure payload was returned in order provided
-    for (const [index, result] of withStorageMeta.entries()) {
-      expect(isId(result)).toBe(true)
-      const id = asId(result)
-      expect(id).toBeDefined()
-      expect(id?.salt).toBe(`${index}`)
-      expect(await PayloadBuilder.dataHash(result)).toEqual(await PayloadBuilder.dataHash(payloads[index]))
-    }
-
-    const results = await archivist.insert(payloads)
-    expect(results.length).toBe(payloads.length)
-
-    // Ensure payload was inserted in order provided
-    for (const [index, result] of results.entries()) {
-      expect(isId(result)).toBe(true)
-      const id = asId(result)
-      expect(id).toBeDefined()
-      if (index > 0) {
-        expect(result._sequence > results[index - 1]._sequence).toBeTrue()
-      }
-      if (index < 99) {
-        expect(result._sequence < results[index + 1]._sequence).toBeTrue()
-      }
-      if (id?.salt !== `${index}`) {
-        console.warn('result-', results[index - 1])
-        console.warn('result', result)
-        console.warn('result+', results[index + 1])
-      }
-      expect(id?.salt).toBe(`${index}`)
-      expect(await PayloadBuilder.dataHash(result)).toEqual(await PayloadBuilder.dataHash(payloads[index]))
-    }
-  })
-
-  it('next', async () => {
-    const archivist = await LmdbArchivist.create({
-      account: await HDWallet.random(),
-      config: {
-        schema: LmdbArchivistConfigSchema, location: tmpdir(), dbName: 'test3.db', storeName: 'payloads', clearStoreOnStart: true,
-      },
-    })
-    const account = await HDWallet.random()
-
-    const payloads1 = [
-      { schema: 'network.xyo.test', value: 1 },
-    ]
-
-    const payloads2 = [
-      { schema: 'network.xyo.test', value: 2 },
-    ]
-
-    const payloads3 = [
-      { schema: 'network.xyo.test', value: 3 },
-    ]
-
-    const payloads4 = [
-      { schema: 'network.xyo.test', value: 4 },
-    ]
-
-    const insertedPayloads1 = await archivist.insert(payloads1)
-    expect(insertedPayloads1[0]._hash).toBe(await PayloadBuilder.hash(payloads1[0]))
-    expect(insertedPayloads1[0]._dataHash).toBe(await PayloadBuilder.dataHash(payloads1[0]))
-    expect(insertedPayloads1[0]._sequence).toBeDefined()
-    await delay(1)
-    console.log(toSafeJsonString(payloads1, 10))
-    const [bw, payloads, errors] = await archivist.insertQuery(payloads2, account)
-    expect(bw).toBeDefined()
-    expect(payloads).toBeDefined()
-    expect(errors).toBeDefined()
-    await delay(1)
-    await archivist.insert(payloads3)
-    await delay(1)
-    await archivist.insert(payloads4)
-
-    console.log('bw', toSafeJsonString([bw, payloads, errors], 10))
-
-    const batch1 = await archivist.next?.({ limit: 2 })
-    expect(batch1).toBeArrayOfSize(2)
-    expect(await PayloadBuilder.dataHash(batch1?.[0])).toEqual(await PayloadBuilder.dataHash(payloads1[0]))
-    expect(await PayloadBuilder.dataHash(batch1?.[0])).toEqual(await PayloadBuilder.dataHash(insertedPayloads1[0]))
-
-    const batch2 = await archivist.next?.({ limit: 2, cursor: batch1?.[0]._sequence })
-    expect(batch2).toBeArrayOfSize(2)
-    expect(await PayloadBuilder.dataHash(batch2?.[0])).toEqual(await PayloadBuilder.dataHash(payloads2[0]))
-    expect(await PayloadBuilder.dataHash(batch2?.[1])).toEqual(await PayloadBuilder.dataHash(payloads3[0]))
-
-    // desc
-    const batch1Desc = await archivist.next?.({ limit: 2, order: 'desc' })
-    expect(batch1Desc).toBeArrayOfSize(2)
-    expect(await PayloadBuilder.dataHash(batch1Desc?.[0])).toEqual(await PayloadBuilder.dataHash(payloads4[0]))
-    expect(await PayloadBuilder.dataHash(batch1Desc?.[1])).toEqual(await PayloadBuilder.dataHash(payloads3[0]))
-
-    const batch2Desc = await archivist.next?.({
-      limit: 2, cursor: batch1Desc[1]._sequence, order: 'desc',
-    })
-    expect(batch2Desc).toBeArrayOfSize(2)
-    expect(await PayloadBuilder.dataHash(batch2Desc?.[0])).toEqual(await PayloadBuilder.dataHash(payloads2[0]))
-    expect(await PayloadBuilder.dataHash(batch2Desc?.[1])).toEqual(await PayloadBuilder.dataHash(payloads1[0]))
-  })
-})