@fireproof/core 0.0.6 → 0.0.8

package/src/prolly.js

@@ -6,13 +6,12 @@ import {
   findEventsToSync
 } from './clock.js'
 import { create, load } from 'prolly-trees/map'
+// import { create, load } from '../../../../prolly-trees/src/map.js'
+import { nocache as cache } from 'prolly-trees/cache'
+import { CIDCounter, bf, simpleCompare as compare } from 'prolly-trees/utils'
 import * as codec from '@ipld/dag-cbor'
 import { sha256 as hasher } from 'multiformats/hashes/sha2'
-import { MemoryBlockstore, MultiBlockFetcher } from './block.js'
 import { doTransaction } from './blockstore.js'
-
-import { nocache as cache } from 'prolly-trees/cache'
-import { CIDCounter, bf, simpleCompare as compare } from 'prolly-trees/utils'
 import { create as createBlock } from 'multiformats/block'
 const opts = { cache, chunker: bf(3), codec, hasher, compare }
 
@@ -22,9 +21,9 @@ const withLog = async (label, fn) => {
   return resp
 }
 
-// todo should also return a CIDCounter
+// should also return a CIDCounter
 export const makeGetBlock = (blocks) => {
-  // const cids = new CIDCounter() // todo this could be used for proofs of mutations
+  // const cids = new CIDCounter() // this could be used for proofs of mutations
   const getBlockFn = async (address) => {
     const { cid, bytes } = await withLog(address, () => blocks.get(address))
     // cids.add({ address: cid })
@@ -55,18 +54,17 @@ export const makeGetBlock = (blocks) => {
  *   event: CID[]
  * }>}
  */
-async function createAndSaveNewEvent (
+async function createAndSaveNewEvent ({
   inBlocks,
-  mblocks,
-  getBlock,
   bigPut,
   root,
-  { key, value, del },
+  event: inEvent,
   head,
   additions,
   removals = []
-) {
+}) {
   let cids
+  const { key, value, del } = inEvent
   const data = {
     type: 'put',
     root: {
@@ -100,20 +98,20 @@ async function createAndSaveNewEvent (
 }
 
 const makeGetAndPutBlock = (inBlocks) => {
-  const mblocks = new MemoryBlockstore()
-  const blocks = new MultiBlockFetcher(mblocks, inBlocks)
-  const { getBlock, cids } = makeGetBlock(blocks)
+  // const mblocks = new MemoryBlockstore()
+  // const blocks = new MultiBlockFetcher(mblocks, inBlocks)
+  const { getBlock, cids } = makeGetBlock(inBlocks)
   const put = inBlocks.put.bind(inBlocks)
   const bigPut = async (block, additions) => {
     // console.log('bigPut', block.cid.toString())
     const { cid, bytes } = block
     put(cid, bytes)
-    mblocks.putSync(cid, bytes)
+    // mblocks.putSync(cid, bytes)
     if (additions) {
       additions.set(cid.toString(), block)
     }
   }
-  return { getBlock, bigPut, mblocks, blocks, cids }
+  return { getBlock, bigPut, blocks: inBlocks, cids }
 }
 
 const bulkFromEvents = (sorted) =>
@@ -143,7 +141,7 @@ const prollyRootFromAncestor = async (events, ancestor, getBlock) => {
 /**
  * Put a value (a CID) for the given key. If the key exists it's value is overwritten.
  *
- * @param {import('./block').BlockFetcher} blocks Bucket block storage.
+ * @param {import('../test/block.js').BlockFetcher} blocks Bucket block storage.
  * @param {import('./clock').EventLink<EventData>[]} head Merkle clock head.
  * @param {string} key The key of the value to put.
  * @param {CID} value The value to put.
@@ -151,7 +149,7 @@ const prollyRootFromAncestor = async (events, ancestor, getBlock) => {
  * @returns {Promise<Result>}
  */
 export async function put (inBlocks, head, event, options) {
-  const { getBlock, bigPut, mblocks, blocks } = makeGetAndPutBlock(inBlocks)
+  const { getBlock, bigPut, blocks } = makeGetAndPutBlock(inBlocks)
 
   // If the head is empty, we create a new event and return the root and addition blocks
   if (!head.length) {
@@ -161,12 +159,15 @@ export async function put (inBlocks, head, event, options) {
       root = await node.block
       bigPut(root, additions)
     }
-    return createAndSaveNewEvent(inBlocks, mblocks, getBlock, bigPut, root, event, head, Array.from(additions.values()))
+    return createAndSaveNewEvent({ inBlocks, bigPut, root, event, head, additions: Array.from(additions.values()) })
   }
 
   // Otherwise, we find the common ancestor and update the root and other blocks
   const events = new EventFetcher(blocks)
+  // todo this is returning more events than necessary, lets define the desired semantics from the top down
+  // good semantics mean we can cache the results of this call
   const { ancestor, sorted } = await findCommonAncestorWithSortedEvents(events, head)
+  // console.log('sorted', JSON.stringify(sorted.map(({ value: { data: { key, value } } }) => ({ key, value }))))
   const prollyRootNode = await prollyRootFromAncestor(events, ancestor, getBlock)
 
   const bulkOperations = bulkFromEvents(sorted)
@@ -178,22 +179,20 @@ export async function put (inBlocks, head, event, options) {
     bigPut(nb, additions)
   }
   // additions are new blocks
-  return createAndSaveNewEvent(
+  return createAndSaveNewEvent({
     inBlocks,
-    mblocks,
-    getBlock,
     bigPut,
-    prollyRootBlock,
+    root: prollyRootBlock,
     event,
     head,
-    Array.from(additions.values()) /*, todo? Array.from(removals.values()) */
-  )
+    additions: Array.from(additions.values()) /*, todo? Array.from(removals.values()) */
+  })
 }
 
 /**
  * Determine the effective prolly root given the current merkle clock head.
  *
- * @param {import('./block').BlockFetcher} blocks Bucket block storage.
+ * @param {import('../test/block.js').BlockFetcher} blocks Bucket block storage.
  * @param {import('./clock').EventLink<EventData>[]} head Merkle clock head.
  */
 export async function root (inBlocks, head) {
@@ -208,22 +207,22 @@ export async function root (inBlocks, head) {
   // Perform bulk operations (put or delete) for each event in the sorted array
   const bulkOperations = bulkFromEvents(sorted)
   const { root: newProllyRootNode, blocks: newBlocks } = await prollyRootNode.bulk(bulkOperations)
-  const prollyRootBlock = await newProllyRootNode.block
-  // console.log('emphemeral blocks', newBlocks.map((nb) => nb.cid.toString()))
+  // const prollyRootBlock = await newProllyRootNode.block
+  // console.log('newBlocks', newBlocks.map((nb) => nb.cid.toString()))
   // todo maybe these should go to a temp blockstore?
   await doTransaction('root', inBlocks, async (transactionBlockstore) => {
     const { bigPut } = makeGetAndPutBlock(transactionBlockstore)
     for (const nb of newBlocks) {
       bigPut(nb)
     }
-    bigPut(prollyRootBlock)
+    // bigPut(prollyRootBlock)
   })
   return { cids: events.cids, node: newProllyRootNode }
 }
 
 /**
  * Get the list of events not known by the `since` event
- * @param {import('./block').BlockFetcher} blocks Bucket block storage.
+ * @param {import('../test/block.js').BlockFetcher} blocks Bucket block storage.
  * @param {import('./clock').EventLink<EventData>[]} head Merkle clock head.
  * @param {import('./clock').EventLink<EventData>} since Event to compare against.
  * @returns {Promise<import('./clock').EventLink<EventData>[]>}
@@ -239,7 +238,7 @@ export async function eventsSince (blocks, head, since) {
 
 /**
  *
- * @param {import('./block').BlockFetcher} blocks Bucket block storage.
+ * @param {import('../test/block.js').BlockFetcher} blocks Bucket block storage.
  * @param {import('./clock').EventLink<EventData>[]} head Merkle clock head.
  *
  * @returns {Promise<import('./prolly').Entry[]>}
@@ -257,7 +256,7 @@ export async function getAll (blocks, head) {
 }
 
 /**
- * @param {import('./block').BlockFetcher} blocks Bucket block storage.
+ * @param {import('../test/block.js').BlockFetcher} blocks Bucket block storage.
  * @param {import('./clock').EventLink<EventData>[]} head Merkle clock head.
  * @param {string} key The key of the value to retrieve.
  */
@@ -270,3 +269,15 @@ export async function get (blocks, head, key) {
   const { result, cids } = await prollyRootNode.get(key)
   return { result, cids, clockCIDs }
 }
+
+export async function * vis (blocks, head) {
+  if (!head.length) {
+    return { cids: new CIDCounter(), result: null }
+  }
+  const { node: prollyRootNode, cids } = await root(blocks, head)
+  const lines = []
+  for await (const line of prollyRootNode.vis()) {
+    yield line
+  }
+  return { vis: lines.join('\n'), cids }
+}

package/src/valet.js

@@ -3,17 +3,8 @@ import { CID } from 'multiformats/cid'
 import { openDB } from 'idb'
 import cargoQueue from 'async/cargoQueue.js'
 
-// const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
-// let storageSupported = false
-// try {
-//   storageSupported = window.localStorage && true
-// } catch (e) {}
-// const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
-
 export default class Valet {
-  #cars = new Map() // cars by cid
-  #cidToCar = new Map() // cid to car
-  #db = null
+  idb = null
   #uploadQueue = null
   #alreadyEnqueued = new Set()
 
@@ -23,7 +14,8 @@ export default class Valet {
    */
   uploadFunction = null
 
-  constructor () {
+  constructor (name = 'default') {
+    this.name = name
     this.#uploadQueue = cargoQueue(async (tasks, callback) => {
       console.log(
         'queue worker',
@@ -59,9 +51,8 @@ export default class Valet {
   }
 
   withDB = async (dbWorkFun) => {
-    // if (!storageSupported) return
-    if (!this.#db) {
-      this.#db = await openDB('valet', 2, {
+    if (!this.idb) {
+      this.idb = await openDB(`fp.${this.name}.valet`, 2, {
         upgrade (db, oldVersion, newVersion, transaction) {
           if (oldVersion < 1) {
             db.createObjectStore('cars') // todo use database name
@@ -75,7 +66,7 @@ export default class Valet {
         }
       })
     }
-    return await dbWorkFun(this.#db)
+    return await dbWorkFun(this.idb)
   }
 
   /**
@@ -84,11 +75,6 @@ export default class Valet {
    * @param {*} value
    */
   async parkCar (carCid, value, cids) {
-    // this.#cars.set(carCid, value)
-    // for (const cid of cids) {
-    //   this.#cidToCar.set(cid, carCid)
-    // }
-
     await this.withDB(async (db) => {
       const tx = db.transaction(['cars', 'cidToCar'], 'readwrite')
       await tx.objectStore('cars').put(value, carCid)
@@ -130,45 +116,3 @@ export default class Valet {
     })
   }
 }
-
-// export class MemoryValet {
-//   #cars = new Map() // cars by cid
-//   #cidToCar = new Map() // cid to car
-
-//   /**
-//    *
-//    * @param {string} carCid
-//    * @param {*} value
-//    */
-//   async parkCar (carCid, value, cids) {
-//     this.#cars.set(carCid, value)
-//     for (const cid of cids) {
-//       this.#cidToCar.set(cid, carCid)
-//     }
-//   }
-
-//   async getBlock (dataCID) {
-//     return await this.#valetGet(dataCID)
-//   }
-
-//   /**
-//    * Internal function to load blocks from persistent storage.
-//    * Currently it just searches all the cars for the block, but in the future
-//    * we need to index the block CIDs to the cars, and reference that to find the block.
-//    * This index will also allow us to use accelerator links for the gateway when needed.
-//    * It can itself be a prolly tree...
-//    * @param {string} cid
-//    * @returns {Promise<Uint8Array|undefined>}
-//    */
-//   #valetGet = async (cid) => {
-//     const carCid = this.#cidToCar.get(cid)
-//     if (carCid) {
-//       const carBytes = this.#cars.get(carCid)
-//       const reader = await CarReader.fromBytes(carBytes)
-//       const gotBlock = await reader.get(CID.parse(cid))
-//       if (gotBlock) {
-//         return gotBlock.bytes
-//       }
-//     }
-//   }
-// }

package/{src → test}/block.js

@@ -1,8 +1,8 @@
 import { parse } from 'multiformats/link'
 
 /**
- * @typedef {{ cid: import('./link').AnyLink, bytes: Uint8Array }} AnyBlock
- * @typedef {{ get: (link: import('./link').AnyLink) => Promise<AnyBlock | undefined> }} BlockFetcher
+ * @typedef {{ cid: import('../src/link').AnyLink, bytes: Uint8Array }} AnyBlock
+ * @typedef {{ get: (link: import('../src/link').AnyLink) => Promise<AnyBlock | undefined> }} BlockFetcher
  */
 
 /** @implements {BlockFetcher} */
@@ -11,7 +11,7 @@ export class MemoryBlockstore {
   #blocks = new Map()
 
   /**
-   * @param {import('./link').AnyLink} cid
+   * @param {import('../src/link').AnyLink} cid
    * @returns {Promise<AnyBlock | undefined>}
    */
   async get (cid) {
@@ -21,7 +21,7 @@ export class MemoryBlockstore {
   }
 
   /**
-   * @param {import('./link').AnyLink} cid
+   * @param {import('../src/link').AnyLink} cid
    * @param {Uint8Array} bytes
    */
   async put (cid, bytes) {
@@ -30,7 +30,7 @@ export class MemoryBlockstore {
   }
 
   /**
-   * @param {import('./link').AnyLink} cid
+   * @param {import('../src/link').AnyLink} cid
    * @param {Uint8Array} bytes
    */
   putSync (cid, bytes) {
@@ -53,7 +53,7 @@ export class MultiBlockFetcher {
     this.#fetchers = fetchers
   }
 
-  /** @param {import('./link').AnyLink} link */
+  /** @param {import('../src/link').AnyLink} link */
   async get (link) {
     for (const f of this.#fetchers) {
       const v = await f.get(link)

package/test/clock.test.js

@@ -440,13 +440,8 @@ describe('Clock', () => {
     toSync = await testFindEventsToSync(blocks, sinceHead)
     assert.equal(toSync.length, 0)
 
-    // todo do these since heads make sense?
     sinceHead = [...head0, ...head2]
     toSync = await testFindEventsToSync(blocks, sinceHead)
-    // console.log('need', toSync.map(b => b.value.data))
-    // assert.equal(toSync.length, 2) // 0
-    // assert.equal(toSync[0].cid.toString(), event1.cid.toString())
-    // assert.equal(toSync[1].cid.toString(), event2.cid.toString())
   })
 
   it('add two events with some shared parents', async () => {

package/test/db-index.test.js

@@ -2,13 +2,13 @@ import { describe, it, beforeEach } from 'mocha'
 import assert from 'node:assert'
 import Blockstore from '../src/blockstore.js'
 import Fireproof from '../src/fireproof.js'
-import Index from '../src/db-index.js'
+import DbIndex from '../src/db-index.js'
 console.x = function () {}
 
-describe('Index query', () => {
+describe('DbIndex query', () => {
   let database, index
   beforeEach(async () => {
-    database = new Fireproof(new Blockstore(), []) // todo: these need a cloud name aka w3name, add this after we have cloud storage of blocks
+    database = Fireproof.storage()
     const docs = [
       { _id: 'a1s3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c', name: 'alice', age: 40 },
       { _id: 'b2s3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c', name: 'bob', age: 40 },
@@ -24,7 +24,7 @@ describe('Index query', () => {
       assert(response.id, 'should have id')
       assert.equal(response.id, id)
     }
-    index = new Index(database, function (doc, map) {
+    index = new DbIndex(database, function (doc, map) {
       map(doc.age, doc.name)
     })
   })
@@ -36,8 +36,10 @@ describe('Index query', () => {
     assert.equal(result.rows[0].key, 43)
     assert(result.rows[0].value === 'carol', 'correct value')
   })
-  it.skip('query exact key', async () => {
-    const result = await index.query({ key: 43 })
+  it('query exact key', async () => {
+    let result = await index.query({ range: [41, 44] })
+    assert(result.rows[0].key === 43, 'correct key')
+    result = await index.query({ key: 43 })
     assert(result, 'did return result')
     assert(result.rows)
     assert.equal(result.rows.length, 1, 'one row matched')
@@ -111,7 +113,7 @@ describe('Index query', () => {
     await index.query({ range: [51, 54] })
 
     console.x('--- make Xander 53')
-    const DOCID = 'xxxx-3c3a-4b5e-9c1c-8c5c0c5c0c5c'
+    const DOCID = 'xander-doc'
     const r1 = await database.put({ _id: DOCID, name: 'Xander', age: 53 })
     assert(r1.id, 'should have id')
 
@@ -197,12 +199,12 @@ describe('Index query', () => {
   })
 })
 
-describe('Index query with bad index definition', () => {
+describe('DbIndex query with bad index definition', () => {
   let database, index
   beforeEach(async () => {
     database = new Fireproof(new Blockstore(), []) // todo: these need a cloud name aka w3name, add this after we have cloud storage of blocks
     await database.put({ _id: 'a1s3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c', name: 'alice', age: 40 })
-    index = new Index(database, function (doc, map) {
+    index = new DbIndex(database, function (doc, map) {
       map(doc.oops.missingField, doc.name)
     })
   })
@@ -214,5 +216,4 @@ describe('Index query with bad index definition', () => {
       console.error = oldErrFn
     })
   })
-  it.skip('reproduce missing block error from browser so we can turn off always rebuild', async () => {})
 })

package/test/fireproof.test.js

@@ -2,6 +2,7 @@ import { describe, it, beforeEach } from 'mocha'
 import assert from 'node:assert'
 import Blockstore from '../src/blockstore.js'
 import Fireproof from '../src/fireproof.js'
+// import * as codec from '@ipld/dag-cbor'
 
 let database, resp0
 
@@ -9,14 +10,18 @@ let database, resp0
 
 describe('Fireproof', () => {
   beforeEach(async () => {
-    database = new Fireproof(new Blockstore(), []) // todo: these need a cloud name aka w3name, add this after we have cloud storage of blocks
+    database = Fireproof.storage('helloName')
     resp0 = await database.put({
       _id: '1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c',
       name: 'alice',
       age: 42
     })
   })
-
+  it('takes an optional name', () => {
+    assert.equal(database.name, 'helloName')
+    const x = database.blocks.valet.idb
+    assert.equal(x.name.toString(), 'fp.helloName.valet')
+  })
   it('put and get document', async () => {
     assert(resp0.id, 'should have id')
     assert.equal(resp0.id, '1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c')
@@ -27,13 +32,13 @@ describe('Fireproof', () => {
   })
   it('mvcc put and get document with _clock that matches', async () => {
     assert(resp0.clock, 'should have clock')
-    assert.equal(resp0.clock[0].toString(), 'bafyreieth2ckopwivda5mf6vu76xwqvox3q5wsaxgbmxy2dgrd4hfuzmma')
+    assert.equal(resp0.clock[0].toString(), 'bafyreiadhnnxgaeeqdxujfew6zxr4lnjyskkrg26cdjvk7tivy6dt4xmsm')
     const theDoc = await database.get('1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c')
     theDoc._clock = database.clock
     const put2 = await database.put(theDoc)
     assert.equal(put2.id, '1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c')
     assert.equal(put2.clock.length, 1)
-    assert.equal(put2.clock[0].toString(), 'bafyreida2c2ckhjfoz5ulmbbfe66ey4svvedrl4tzbvtoxags2qck7lj2i')
+    assert.equal(put2.clock[0].toString(), 'bafyreib2kck2fv73lgahfcd5imarslgxcmachbxxavhtwahx5ppjfts4qe')
   })
   it('get should return an object instance that is not the same as the one in the db', async () => {
     const theDoc = await database.get('1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c')
@@ -46,7 +51,7 @@ describe('Fireproof', () => {
   it('get with mvcc option', async () => {
     const theDoc = await database.get('1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c', { mvcc: true })
     assert(theDoc._clock, 'should have _clock')
-    assert.equal(theDoc._clock[0].toString(), 'bafyreieth2ckopwivda5mf6vu76xwqvox3q5wsaxgbmxy2dgrd4hfuzmma')
+    assert.equal(theDoc._clock[0].toString(), 'bafyreiadhnnxgaeeqdxujfew6zxr4lnjyskkrg26cdjvk7tivy6dt4xmsm')
   })
   it('get with mvcc option where someone else changed another document first', async () => {
     const theDoc = await database.get('1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c', { mvcc: true })
@@ -237,6 +242,34 @@ describe('Fireproof', () => {
     assert.equal(prevBob.age, 11)
   })
 
+  it('provides docs since tiny', async () => {
+    const result = await database.changesSince()
+    assert.equal(result.rows.length, 1)
+    assert.equal(result.rows[0].key, '1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c')
+
+    // console.log('result', result)
+
+    // const result2 = await database.changesSince(result.clock)
+    // console.log('result2', result2)
+    // assert.equal(result2.rows.length, 0)
+
+    const bKey = 'befbef-3c3a-4b5e-9c1c-bbbbbb'
+    const bvalue = {
+      _id: bKey,
+      name: 'bob',
+      age: 44
+    }
+    const response = await database.put(bvalue)
+    assert(response.id, 'should have id')
+    assert.equal(response.id, bKey)
+
+    const res3 = await database.changesSince()
+    assert.equal(res3.rows.length, 2)
+
+    const res4 = await database.changesSince(result.clock)
+    assert.equal(res4.rows.length, 1)
+  })
+
   it('provides docs since', async () => {
     const result = await database.changesSince()
     assert.equal(result.rows.length, 1)
@@ -275,8 +308,6 @@ describe('Fireproof', () => {
 
     const res5 = await database.changesSince(res4.clock)
 
-    // await database.visClock()
-
     assert.equal(res5.rows.length, 1)
 
     const res6 = await database.changesSince(result2.clock)
@@ -304,26 +335,43 @@ describe('Fireproof', () => {
     assert.equal(res9.rows.length, 0)
   })
 
-  it.skip('docs since repeated changes', async () => {
+  it('docs since repeated changes', async () => {
     assert.equal((await database.changesSince()).rows.length, 1)
     let resp, doc, changes
-    for (let index = 0; index < 200; index++) {
-      const id = '' + (300 - index).toString()
+    for (let index = 0; index < 30; index++) {
+      const id = '1' + (301 - index).toString()
+      // console.log(`Putting id: ${id}, index: ${index}`)
       resp = await database.put({ index, _id: id }).catch(e => {
-        assert.equal(e.message, 'put failed on  _id: ' + id)
+        assert.fail(`put failed on _id: ${id}, error: ${e.message}`)
       })
-      assert(resp.id)
+      assert(resp.id, `Failed to obtain resp.id for _id: ${id}`)
+
+      // console.log(`vis for update id: ${id}, index:`, index)
+      // for await (const line of database.vis()) {
+      //   console.log(line)
+      // }
+
       doc = await database.get(resp.id).catch(e => {
-        console.trace('failed', e)
-        assert.equal(e.message, 'get failed on _id: ' + id)
+        console.log('failed', e)
+        assert.fail(`get failed on _id: ${id}, error: ${e.message}`)
       })
-      assert.equal(doc.index, index)
-      changes = await database.changesSince().catch(e => {
-        assert.equal(e.message, 'changesSince failed on  _id: ' + id)
+
+      assert.equal(doc.index, index, `doc.index is not equal to index for _id: ${id}`)
+      changes = await database.changesSince().catch(async e => {
+        assert.fail(`changesSince failed on _id: ${id}, error: ${e.message}`)
+      })
+      changes.rows.forEach(row => {
+        for (const key in row) {
+          const value = row[key]
+          assert(!/^bafy/.test(value), `Unexpected "bafy..." value found at index ${index} in row ${JSON.stringify(row)}`)
+        }
       })
-      assert.equal(changes.rows.length, index + 2)
+
+      // console.log('changes: ', index, changes.rows.length, JSON.stringify(changes.rows))
+      assert.equal(changes.rows.length, index + 2, `failed on ${index}, with ${changes.rows.length} ${id}`)
     }
-  }).timeout(20000)
+  }).timeout(30000)
+
   it('concurrent transactions', async () => {
     assert.equal((await database.changesSince()).rows.length, 1)
     const promises = []
@@ -356,4 +404,11 @@ describe('Fireproof', () => {
     // await sleep(1000)
     assert.equal((await database.changesSince()).rows.length, 2)
   }).timeout(20000)
+  it('serialize database', async () => {
+    await database.put({ _id: 'rehy', name: 'drate' })
+    assert.equal((await database.changesSince()).rows.length, 2)
+    const serialized = JSON.parse(JSON.stringify(database))
+    assert.equal(serialized.name, 'helloName')
+    assert.equal(serialized.clock.length, 1)
+  })
 })

package/test/helpers.js

@@ -3,7 +3,7 @@ import crypto from 'node:crypto'
 import * as Link from 'multiformats/link'
 import * as raw from 'multiformats/codecs/raw'
 import { sha256 } from 'multiformats/hashes/sha2'
-import { MemoryBlockstore } from '../src/block.js'
+import { MemoryBlockstore } from './block.js'
 
 // console.x = console.log
 // console.log = function (...args) {