@fireproof/core 0.0.5 → 0.0.7

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')
@@ -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)
     })
   })

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,12 +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[0].toString(), 'bafyreida2c2ckhjfoz5ulmbbfe66ey4svvedrl4tzbvtoxags2qck7lj2i')
+    assert.equal(put2.clock.length, 1)
+    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')
@@ -45,7 +51,17 @@ 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 })
+    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
@@ -226,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)
@@ -264,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)
@@ -297,22 +339,48 @@ describe('Fireproof', () => {
     assert.equal((await database.changesSince()).rows.length, 1)
     let resp, doc, changes
     for (let index = 0; index < 200; index++) {
-      const id = '' + (300 - index).toString()
+      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, `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}`)
       })
-      assert.equal(doc.index, index)
-      changes = await database.changesSince().catch(e => {
-        assert.equal(e.message, 'changesSince failed on  _id: ' + id)
+      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)
+      if (index > 3) {
+        const stored = await database.blocks.get('bafyreicumn7tvssch4xslbe4jjq55c6w3jt4yxyjagkr2tengsudato7vi').catch((e) => {
+          console.log(`Error getting block for index ${index}: ${e.message}`)
+        })
+        if (stored) {
+          const doc = codec.decode(await stored.bytes)
+          // console.log('stored', JSON.stringify(dec))
+          assert.equal(doc.closed, false)
+        }
+      }
+      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)
+
   it('concurrent transactions', async () => {
     assert.equal((await database.changesSince()).rows.length, 1)
     const promises = []

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/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) {

package/test/prolly.test.js

@@ -110,7 +110,7 @@ describe('Prolly', () => {
     assert.equal(bvalue.toString(), data[0][1].toString())
   })
 
-  it.skip('linear put hundreds of values', async () => {
+  it.skip('passing, slow: linear put hundreds of values', async () => {
     const blocks = new Blockstore()
     const alice = new TestPail(blocks, [])
 
@@ -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('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], 'bafyreieilmvxq6wudu46i2ssmuyrmaszr4onzlqxzlvngrczbn7ppyvloq')
+    assert.equal(doc._proof.clock[0].toString(), 'bafyreict4aip45uwnm4xcsn4oikh73t5n7nzdmc2u36rdbguroun2yaf2y')
+  })
+})

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 }))
+  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',
-      })
-    }
-  }
-}
- ```
-
- 

package/scripts/propernames/gen.sh

@@ -1,3 +0,0 @@
-while read p; do
-  pail put $p $(node ../randomcid.js) --max-shard-size=10000
-done </usr/share/dict/propernames

package/scripts/randomcid.js

@@ -1,12 +0,0 @@
-import crypto from 'node:crypto'
-import { CID } from 'multiformats/cid'
-import * as raw from 'multiformats/codecs/raw'
-import { sha256 } from 'multiformats/hashes/sha2'
-
-async function main () {
-  const bytes = crypto.webcrypto.getRandomValues(new Uint8Array(32))
-  const hash = await sha256.digest(bytes)
-  process.stdout.write(CID.create(1, raw.code, hash).toString())
-}
-
-main()