@fireproof/core 0.0.5 → 0.0.6

package/test/db-index.test.js

@@ -214,4 +214,5 @@ 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

@@ -32,6 +32,7 @@ describe('Fireproof', () => {
     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')
   })
   it('get should return an object instance that is not the same as the one in the db', async () => {
@@ -47,6 +48,16 @@ describe('Fireproof', () => {
     assert(theDoc._clock, 'should have _clock')
     assert.equal(theDoc._clock[0].toString(), 'bafyreieth2ckopwivda5mf6vu76xwqvox3q5wsaxgbmxy2dgrd4hfuzmma')
   })
+  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 })
+    const put2 = await database.put({ something: 'else' })
+    assert(put2.clock, 'should have clock')
+    assert.notEqual(put2.clock.toString(), resp0.clock.toString())
+    assert.equal(theDoc._clock.toString(), resp0.clock.toString())
+    theDoc.name = 'somone else'
+    const put3works = await database.put(theDoc)
+    assert(put3works.clock, 'should have id')
+  })
   it('get from an old snapshot with mvcc option', async () => {
     const ogClock = resp0.clock
     const theDoc = await database.get('1ef3b32a-3c3a-4b5e-9c1c-8c5c0c5c0c5c')

package/test/fulltext.test.js

@@ -0,0 +1,66 @@
+import { describe, it, beforeEach } from 'mocha'
+import assert from 'node:assert'
+import Fireproof from '../src/fireproof.js'
+import flexsearch from 'flexsearch'
+const { Index } = flexsearch
+// this is an illustration of how to use the flexsearch library
+
+let database, flexed
+
+describe('Fulltext with flexsearch', () => {
+  beforeEach(async () => {
+    database = Fireproof.storage()
+    flexed = withFlexsearch(database) // this is a function that adds the flexsearch library to the database object
+
+    const messages = [
+      'Hello World, this is a test',
+      'We are testing the flexsearch library',
+      'When we test we test',
+      'Apples are red',
+      'Bananas are yellow',
+      'Oranges are orange',
+      'Pears are green',
+      'Grapes are purple',
+      'Strawberries are red',
+      'Blueberries are blue',
+      'Raspberries are red',
+      'Watermelons are green',
+      'Pineapples are yellow'
+    ]
+    for (let i = 0, len = messages.length; i < len; i++) {
+      await database.put({
+        _id: `message-${i}`,
+        message: messages[i]
+      })
+    }
+  })
+
+  it('search the index', async () => {
+    const changes = await database.changesSince()
+    assert.equal(changes.rows.length, 13)
+    const results = await flexed.search('red')
+    assert.equal(results.length, 3)
+    for (let i = 0, len = results.length; i < len; i++) {
+      const doc = await database.get(results[i])
+      assert.match(doc.message, /red/)
+    }
+  })
+  // it('add more docs and search again', async () => {})
+  // it('delete some docs and search again', async () => {})
+  // it('update some docs and search again', async () => {})
+})
+
+function withFlexsearch (database, flexsearchOptions = {}) {
+  const index = new Index(flexsearchOptions)
+  let clock = null
+  const search = async (query, options) => {
+    const changes = await database.changesSince(clock)
+    clock = changes.clock
+    for (let i = 0; i < changes.rows.length; i++) {
+      const { key, value } = changes.rows[i]
+      await index.add(key, value.message)
+    }
+    return index.search(query, options)
+  }
+  return { search }
+}

package/test/prolly.test.js

@@ -146,9 +146,11 @@ class TestPail {
    */
   async put (key, value) {
     const result = await put(this.blocks, this.head, { key, value })
-    if (!result) { console.log('failed', key, value) }
+    if (!result) {
+      console.log('failed', key, value)
+    }
     this.blocks.putSync(result.event.cid, result.event.bytes)
-    result.additions.forEach(a => this.blocks.putSync(a.cid, a.bytes))
+    result.additions.forEach((a) => this.blocks.putSync(a.cid, a.bytes))
     this.head = result.head
     this.root = result.root.cid
     // this difference probably matters, but we need to test it
@@ -162,42 +164,27 @@ class TestPail {
 
   /** @param {import('../src/clock').EventLink<import('../src/crdt').EventData>} event */
   async advance (event) {
-    this.head = await advance(this.blocks, this.head, event)
-    this.root = (await root(this.blocks, this.head)).block.cid
+    const { head } = await advance(this.blocks, this.head, event)
+    this.head = head
+    this.root = (await root(this.blocks, this.head)).node.block.cid
     return this.head
   }
 
-  // /**
-  //  * @param {string} key
-  //  * @param {import('../src/link.js').AnyLink} value
-  //  */
-  // async putAndVis (key, value) {
-  //   const result = await this.put(key, value)
-  //   /** @param {import('../src/link').AnyLink} l */
-  //   const shortLink = l => `${String(l).slice(0, 4)}..${String(l).slice(-4)}`
-  //   /** @type {(e: import('../src/clock').EventBlockView<import('../src/crdt').EventData>) => string} */
-  //   const renderNodeLabel = event => {
-  //     return event.value.data.type === 'put'
-  //       ? `${shortLink(event.cid)}\\nput(${event.value.data.key}, ${shortLink(event.value.data.value)})`
-  //       : `${shortLink(event.cid)}\\ndel(${event.value.data.key})`
-  //   }
-  //   for await (const line of vis(this.blocks, result.head, { renderNodeLabel })) {
-  //     console.log(line)
-  //   }
-  //   return result
-  // }
-
   /** @param {string} key */
   async get (key) {
-    return get(this.blocks, this.head, key)
+    const resp = await get(this.blocks, this.head, key)
+    console.log('prolly GET', key, resp)
+    return resp.result
   }
 
   /** @param {string} key */
   async getAll () {
-    return getAll(this.blocks, this.head)
+    const resp = await getAll(this.blocks, this.head)
+    return resp.result
   }
 
   async getSince (since) {
-    return eventsSince(this.blocks, this.head, since)
+    const resp = await eventsSince(this.blocks, this.head, since)
+    return resp.result
   }
 }

package/test/proofs.test.js

@@ -0,0 +1,53 @@
+import { describe, it, beforeEach } from 'mocha'
+import assert from 'node:assert'
+import Fireproof from '../src/fireproof.js'
+
+let database, ok, doc
+
+describe('Proofs', () => {
+  beforeEach(async () => {
+    database = Fireproof.storage()
+    ok = await database.put({
+      _id: 'test1',
+      score: 75
+    })
+    doc = await database.get(ok.id, { mvcc: true })
+  })
+
+  it.skip('first put result shoud not include proof', async () => {
+    assert(ok.proof)
+    assert(ok.proof.data)
+    assert(ok.proof.clock)
+    console.log('ok', ok)
+    assert.equal(ok.proof.data.length, 0)
+    assert.equal(ok.proof.clock.length, 0)
+
+    // assert.equal(ok.proof.data[0], 'bafyreibsbxxd4ueujryihk6xza2ekwhzsh6pzuu5fysft5ilz7cbw6bjju')
+    // assert.equal(ok.proof.clock[0].toString(), 'bafyreiactx5vku7zueq27i5zdrgcjnczxvepceo5yszjqb2exufwrwxg44')
+  })
+
+  it.skip('second put result shoud include proof', async () => {
+    const ok2 = await database.put({ ...doc, winner: true })
+    assert(ok2.proof)
+    assert(ok2.proof.data)
+    assert(ok2.proof.clock)
+    console.log('ok2', ok2)
+    assert.equal(ok2.proof.data.length, 1)
+    assert.equal(ok2.proof.clock.length, 1)
+
+    // assert.equal(ok.proof.data[0], 'bafyreibsbxxd4ueujryihk6xza2ekwhzsh6pzuu5fysft5ilz7cbw6bjju')
+    // assert.equal(ok.proof.clock[0].toString(), 'bafyreiactx5vku7zueq27i5zdrgcjnczxvepceo5yszjqb2exufwrwxg44')
+  })
+
+  it('get result shoud include proof', async () => {
+    assert(doc._clock)
+    assert(doc._proof)
+
+    assert(doc._proof.data)
+    assert(doc._proof.clock)
+    assert.equal(doc._proof.data.length, 1)
+    assert.equal(doc._proof.clock.length, 1)
+    assert.equal(doc._proof.data[0], 'bafyreibsbxxd4ueujryihk6xza2ekwhzsh6pzuu5fysft5ilz7cbw6bjju')
+    assert.equal(doc._proof.clock[0].toString(), 'bafyreiactx5vku7zueq27i5zdrgcjnczxvepceo5yszjqb2exufwrwxg44')
+  })
+})

package/test/reproduce-fixture-bug.test.js

@@ -0,0 +1,65 @@
+import { describe, it, beforeEach } from 'mocha'
+import assert from 'node:assert'
+import Fireproof from '../src/fireproof.js'
+import DbIndex from '../src/db-index.js'
+
+let database
+
+describe('IPLD encode error', () => {
+  beforeEach(async () => {
+    database = Fireproof.storage()
+    defineIndexes(database)
+  })
+
+  it('reproduce', async () => {
+    await loadFixtures(database)
+    assert(true)
+  })
+})
+
+const defineIndexes = (database) => {
+  database.allLists = new DbIndex(database, function (doc, map) {
+    if (doc.type === 'list') map(doc.type, doc)
+  })
+  database.todosByList = new DbIndex(database, function (doc, map) {
+    if (doc.type === 'todo' && doc.listId) {
+      map([doc.listId, doc.createdAt], doc)
+    }
+  })
+  return database
+}
+
+function mulberry32 (a) {
+  return function () {
+    let t = (a += 0x6d2b79f5)
+    t = Math.imul(t ^ (t >>> 15), t | 1)
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+  }
+}
+const rand = mulberry32(1) // determinstic fixtures
+
+async function loadFixtures (database) {
+  const nextId = (prefix = '') => prefix + rand().toString(32).slice(2)
+  const ok = await database.put({ title: 'Building Apps', type: 'list', _id: nextId() })
+
+  await database.put({
+    _id: nextId(),
+    title: 'In the browser',
+    listId: ok.id,
+    completed: rand() > 0.75,
+    type: 'todo',
+    createdAt: '2'
+  })
+  await reproduceBug(database)
+}
+
+const reproduceBug = async (database) => {
+  const id = '02pkji8'
+  const doc = await database.get(id)
+  // (await database.put({ completed: !completed, ...doc }))
+  const ok = await database.put(doc)
+  await database.todosByList.query({ range: [0, 1] })
+
+  console.log('ok', ok)
+}

package/hooks/use-fireproof.md

@@ -1,149 +0,0 @@
-# useFireproof hook for React
-
- React hook to initialize a Fireproof database, automatically saving and loading the clock.
- 
- The hook takes two optional setup function arguments, `defineDatabaseFn` and `setupDatabaseFn`. See below for examples.
- 
-The return value looks like `{ ready, database, addSubscriber }` where the `database` is your Fireproof instance that you can interact with using `put` and `get`, or via your indexes. The `ready` flag turns true after setup completes, you can use this to activate your UI. The `addSubscriber` function is used to update your app in realtime, see example. 
-
-## Usage Example
-
-In App.js:
-
-```js
-import { FireproofCtx, useFireproof } from '@fireproof/core/hooks/use-fireproof'
-
-function App() {
-  // establish the Fireproof context value
-  const fpCtxValue = useFireproof()
-
-  // render the rest of the application wrapped in the Fireproof provider
-  return (
-    <FireproofCtx.Provider value={fpCtxValue}>
-        <MyComponent />
-    </FireproofCtx.Provider>
-  )
-}
-```
-
-In your components:
-
-```js
-import { FireproofCtx } from '@fireproof/core/hooks/use-fireproof'
-
-function MyComponent() {
-  // get Fireproof context
-  const { ready, database, addSubscriber } = useContext(FireproofCtx)
-
-  // set a default empty document
-  const [doc, setDoc] = useState({})
-  
-  // function to load the document from the database
-  const getDataFn = async () => {
-    setDoc(await database.get("my-doc-id"))
-  }
-
-  // run that function when the database changes
-  addSubscriber('MyComponent', getDataFn)
-
-  // run the loader on first mount
-  useEffect(() => getDataFn(), [])
-
-  // a function to change the value of the document
-  const updateFn = async () => {
-    await database.put({ _id : "my-doc-id", hello: "world", updated_at: new Date()})
-  }
-
-  // render the document with a click handler to update it
-  return <pre onclick={updateFn}>JSON.stringify(doc)</pre>
-}
-```
-
-This should result in a tiny application that updates the document when you click it. In a real appliction you'd probably query an index to present eg. all of the photos in a gallery.
-
-## Setup Functions
-
-### defineDatabaseFn 
- 
- Synchronous function that defines the database, run this before any async calls. You can use it to do stuff like set up Indexes. Here's an example:
-
- ```js
- const defineIndexes = (database) => {
-  database.allLists = new Index(database, function (doc, map) {
-    if (doc.type === 'list') map(doc.type, doc)
-  })
-  database.todosByList = new Index(database, function (doc, map) {
-    if (doc.type === 'todo' && doc.listId) {
-      map([doc.listId, doc.createdAt], doc)
-    }
-  })
-  window.fireproof = database // 🤫 for dev
-  return database
-}
- ```
-
-### setupDatabaseFn
-
- Asynchronous function that uses the database when it's ready, run this to load fixture data, insert a dataset from somewhere else, etc. Here's a simple example:
-
-
-```
-async function setupDatabase(database)) {
-    const apiData = await (await fetch('https://dummyjson.com/products')).json()
-    for (const product of apiData.products) {
-        await database.put(product)
-    }  
-}
-```
-
-Note there are no protections against you running the same thing over and over again, so you probably want to put some logic in there to do the right thing.
-
-Here is an example of generating deterministic fixtures, using `mulberry32` for determinstic randomness so re-runs give the same CID, avoiding unnecessary bloat at development time, taken from the TodoMVC demo app.
-
- ```js
- function mulberry32(a) {
-  return function () {
-    let t = (a += 0x6d2b79f5)
-    t = Math.imul(t ^ (t >>> 15), t | 1)
-    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
-    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
-  }
-}
-const rand = mulberry32(1) // determinstic fixtures
-
-export default async function loadFixtures(database) {
-  const nextId = (prefix = '') => prefix + rand().toString(32).slice(2)
-  const listTitles = ['Building Apps', 'Having Fun', 'Getting Groceries']
-  const todoTitles = [
-    [
-      'In the browser',
-      'On the phone',
-      'With or without Redux',
-      'Login components',
-      'GraphQL queries',
-      'Automatic replication and versioning',
-    ],
-    ['Rollerskating meetup', 'Motorcycle ride', 'Write a sci-fi story with ChatGPT'],
-    ['Macadamia nut milk', 'Avocado toast', 'Coffee', 'Bacon', 'Sourdough bread', 'Fruit salad'],
-  ]
-  let ok
-  for (let j = 0; j < 3; j++) {
-    ok = await database.put({ 
-        title: listTitles[j], 
-        type: 'list', 
-        _id: nextId('' + j) 
-    })
-    for (let i = 0; i < todoTitles[j].length; i++) {
-      await database.put({
-        _id: nextId(),
-        title: todoTitles[j][i],
-        listId: ok.id,
-        completed: rand() > 0.75,
-        type: 'todo',
-      })
-    }
-  }
-}
- ```
-
-