@fireproof/core 0.10.0-dev → 0.10.1-dev

package/src/store.ts

@@ -1,32 +0,0 @@
-import { parse } from 'multiformats/link'
-import { AnyLink } from './types'
-
-export class StoredHeader {
-  car: AnyLink
-  constructor(jsonHeader: { car: string }) {
-    this.car = parse(jsonHeader.car)
-  }
-}
-
-export class HeaderStore {
-  name: string
-  constructor(name: string) {
-    this.name = name
-  }
-
-  makeHeader(car: AnyLink): string {
-    return JSON.stringify({ car: car.toString() })
-  }
-
-  parseHeader(headerData: string) {
-    const header = JSON.parse(headerData) as { car: string }
-    return new StoredHeader(header)
-  }
-}
-
-export class CarStore {
-  name: string
-  constructor(name: string) {
-    this.name = name
-  }
-}

package/src/transaction.ts

@@ -1,68 +0,0 @@
-import { MemoryBlockstore } from '@alanshaw/pail/block'
-import { BlockFetcher, AnyBlock, AnyLink, BulkResult, ClockHead } from './types'
-import { Loader } from './loader'
-import { CID } from 'multiformats'
-
-/** forked from
- * https://github.com/alanshaw/pail/blob/main/src/block.js
- * thanks Alan
-**/
-
-export class Transaction extends MemoryBlockstore {
-  constructor(private parent: BlockFetcher) {
-    super()
-    this.parent = parent
-  }
-
-  async get(cid: AnyLink): Promise<AnyBlock | undefined> {
-    return this.parent.get(cid)
-  }
-
-  async superGet(cid: AnyLink): Promise<AnyBlock | undefined> {
-    return super.get(cid)
-  }
-}
-
-export class TransactionBlockstore implements BlockFetcher {
-  name: string | null = null
-  ready: Promise<{ head: ClockHead }> // todo this will be a map of headers by branch name
-
-  private transactions: Set<Transaction> = new Set()
-  private loader: Loader | null = null
-
-  constructor(name?: string, loader?: Loader) {
-    if (name) {
-      this.name = name
-      this.loader = loader || new Loader(name)
-      this.ready = this.loader.ready
-    } else {
-      this.ready = Promise.resolve({ head: [] })
-    }
-  }
-
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async put() {
-    throw new Error('use a transaction to put')
-  }
-
-  async get(cid: AnyLink): Promise<AnyBlock | undefined> {
-    for (const f of this.transactions) {
-      const v = await f.superGet(cid)
-      if (v) return v
-    }
-    if (!this.loader) return
-    return await this.loader.getBlock(cid as CID)
-  }
-
-  async transaction(fn: (t: Transaction) => Promise<BulkResult>) {
-    const t = new Transaction(this)
-    this.transactions.add(t)
-    const done: BulkResult = await fn(t)
-    if (done) { return { ...done, car: await this.commit(t, done) } }
-    return done
-  }
-
-  async commit(t: Transaction, done: BulkResult): Promise<AnyLink | undefined> {
-    return await this.loader?.commit(t, done)
-  }
-}

package/src/types.d.ts

@@ -1,38 +0,0 @@
-import { Link } from 'multiformats'
-import { EventLink } from '@alanshaw/pail/clock'
-import { EventData } from '@alanshaw/pail/crdt'
-
-export type ClockHead = EventLink<EventData>[]
-
-export type BulkResult = {
-  head: ClockHead
-  car?: AnyLink
-}
-
-type DocBody = {
-  [key: string]: any
-}
-
-export type Doc = DocBody & {
-  _id: string
-}
-
-export type DocUpdate = {
-  key: string
-  value?: DocBody
-  del?: boolean
-}
-
-export type DocValue = {
-  doc?: DocBody
-  del?: boolean
-}
-
-export type AnyLink = Link<unknown, number, number, 1 | 0>
-export type AnyBlock = { cid: AnyLink; bytes: Uint8Array }
-export type BlockFetcher = { get: (link: AnyLink) => Promise<AnyBlock | undefined> }
-
-export type DbResponse = {
-  id: string
-  clock: ClockHead
-}

package/test/crdt.test.js

@@ -1,142 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/require-await */
-/* eslint-disable mocha/max-top-level-suites */
-import { assert, equals, notEquals } from './helpers.js'
-import { CRDT } from '../dist/crdt.esm.js'
-
-describe('Fresh crdt', function () {
-  /** @type {CRDT} */
-  let crdt
-  beforeEach(function () {
-    crdt = new CRDT()
-  })
-  it('should have an empty head', async function () {
-    const head = crdt._head
-    equals(head.length, 0)
-  })
-  it('should accept put and return results', async function () {
-    const didPut = await crdt.bulk([{ key: 'hello', value: { hello: 'world' } }])
-    const head = didPut.head
-    equals(head.length, 1)
-  })
-  it('should accept multi-put and return results', async function () {
-    const didPut = await crdt.bulk([{ key: 'ace', value: { points: 11 } }, { key: 'king', value: { points: 10 } }])
-    const head = didPut.head
-    equals(head.length, 1)
-  })
-})
-
-describe('CRDT with one record', function () {
-  /** @type {CRDT} */
-  let crdt, firstPut
-  beforeEach(async function () {
-    crdt = new CRDT()
-    firstPut = await crdt.bulk([{ key: 'hello', value: { hello: 'world' } }])
-  })
-  it('should have a one-element head', async function () {
-    const head = crdt._head
-    equals(head.length, 1)
-  })
-  it('should return the head', async function () {
-    equals(firstPut.head.length, 1)
-  })
-  it('return the record on get', async function () {
-    const got = await crdt.get('hello')
-    assert(got)
-    const value = got.doc
-    equals(value.hello, 'world')
-  })
-  it('should accept another put and return results', async function () {
-    const didPut = await crdt.bulk([{ key: 'nice', value: { nice: 'data' } }])
-    const head = didPut.head
-    equals(head.length, 1)
-    const { doc } = await crdt.get('nice')
-    equals(doc.nice, 'data')
-  })
-  it('should allow for a delete', async function () {
-    const didDel = await crdt.bulk([{ key: 'hello', del: true }])
-    assert(didDel.head)
-    const got = await crdt.get('hello')
-    assert(!got)
-  })
-  it('should offer changes', async function () {
-    const { result } = await crdt.changes([])
-    equals(result.length, 1)
-    equals(result[0].key, 'hello')
-    equals(result[0].value.hello, 'world')
-  })
-})
-
-describe('CRDT with a multi-write', function () {
-  /** @type {CRDT} */
-  let crdt, firstPut
-  beforeEach(async function () {
-    crdt = new CRDT()
-    firstPut = await crdt.bulk([{ key: 'ace', value: { points: 11 } }, { key: 'king', value: { points: 10 } }])
-  })
-  it('should have a one-element head', async function () {
-    const head = crdt._head
-    equals(head.length, 1)
-    equals(firstPut.head.length, 1)
-  })
-  it('return the records on get', async function () {
-    const { doc } = await crdt.get('ace')
-    equals(doc.points, 11)
-
-    const got2 = await crdt.get('king')
-    assert(got2)
-    equals(got2.doc.points, 10)
-  })
-  it('should accept another put and return results', async function () {
-    const didPut = await crdt.bulk([{ key: 'queen', value: { points: 10 } }])
-    const head = didPut.head
-    equals(head.length, 1)
-    const got = await crdt.get('queen')
-    assert(got)
-    equals(got.doc.points, 10)
-  })
-  it('should offer changes', async function () {
-    const { result } = await crdt.changes([])
-    equals(result.length, 2)
-    equals(result[0].key, 'ace')
-    equals(result[0].value.points, 11)
-    equals(result[1].key, 'king')
-  })
-})
-
-describe('CRDT with two multi-writes', function () {
-  /** @type {CRDT} */
-  let crdt, firstPut, secondPut
-  beforeEach(async function () {
-    crdt = new CRDT()
-    firstPut = await crdt.bulk([{ key: 'ace', value: { points: 11 } }, { key: 'king', value: { points: 10 } }])
-    secondPut = await crdt.bulk([{ key: 'queen', value: { points: 10 } }, { key: 'jack', value: { points: 10 } }])
-  })
-  it('should have a one-element head', async function () {
-    const head = crdt._head
-    equals(head.length, 1)
-    equals(firstPut.head.length, 1)
-    equals(secondPut.head.length, 1)
-    notEquals(firstPut.head[0], secondPut.head[0])
-  })
-  it('return the records on get', async function () {
-    const { doc } = await crdt.get('ace')
-    equals(doc.points, 11)
-
-    for (const key of ['king', 'queen', 'jack']) {
-      const { doc } = await crdt.get(key)
-      equals(doc.points, 10)
-    }
-  })
-  it('should offer changes', async function () {
-    const { result } = await crdt.changes([])
-    equals(result.length, 4)
-    equals(result[0].key, 'ace')
-    equals(result[0].value.points, 11)
-    equals(result[1].key, 'king')
-    equals(result[2].key, 'queen')
-    equals(result[3].key, 'jack')
-  })
-})

package/test/database.test.js

@@ -1,144 +0,0 @@
-/* eslint-disable mocha/max-top-level-suites */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import { assert, equals, notEquals, matches } from './helpers.js'
-import { Database } from '../dist/database.esm.js'
-// import { Doc } from '../dist/types.d.esm.js'
-
-/**
- * @typedef {Object.<string, any>} DocBody
- */
-
-/**
- * @typedef {Object} Doc
- * @property {string} _id
- * @property {DocBody} [property] - an additional property
- */
-
-describe('basic Database', function () {
-  /** @type {Database} */
-  let db
-  beforeEach(function () {
-    db = new Database()
-  })
-  it('should put', async function () {
-    /** @type {Doc} */
-    const doc = { _id: 'hello', value: 'world' }
-    const ok = await db.put(doc)
-    equals(ok.id, 'hello')
-  })
-  it('get missing should throw', async function () {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-return
-    const e = await (db.get('missing')).catch(e => e)
-    matches(e.message, /Not found/)
-  })
-  it('del missing should result in deleted state', async function () {
-    await db.del('missing')
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-return
-    const e = await (db.get('missing')).catch(e => e)
-    matches(e.message, /Not found/)
-  })
-  it('has no changes', async function () {
-    const { rows } = await db.changes([])
-    equals(rows.length, 0)
-  })
-})
-
-describe('basic Database with record', function () {
-  /** @type {Database} */
-  let db
-  beforeEach(async function () {
-    db = new Database()
-    /** @type {Doc} */
-    const doc = { _id: 'hello', value: 'world' }
-    const ok = await db.put(doc)
-    equals(ok.id, 'hello')
-  })
-  it('should get', async function () {
-    const doc = await db.get('hello')
-    assert(doc)
-    equals(doc._id, 'hello')
-    equals(doc.value, 'world')
-  })
-  it('should update', async function () {
-    const ok = await db.put({ _id: 'hello', value: 'universe' })
-    equals(ok.id, 'hello')
-    const doc = await db.get('hello')
-    assert(doc)
-    equals(doc._id, 'hello')
-    equals(doc.value, 'universe')
-  })
-  it('should del last record', async function () {
-    const ok = await db.del('hello')
-    equals(ok.id, 'hello')
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    const e = await (db.get('hello')).catch(e => e)
-    matches(e.message, /Not found/)
-  })
-  it('has changes', async function () {
-    const { rows } = await db.changes([])
-    equals(rows.length, 1)
-    equals(rows[0].key, 'hello')
-    equals(rows[0].value._id, 'hello')
-  })
-})
-
-describe('basic Database parallel writes', function () {
-  /** @type {Database} */
-  let db
-  const writes = []
-  beforeEach(async function () {
-    db = new Database()
-    /** @type {Doc} */
-    for (let i = 0; i < 10; i++) {
-      const doc = { _id: `id-${i}`, hello: 'world' }
-      writes.push(db.put(doc))
-    }
-    await Promise.all(writes)
-  })
-  it('should have one head', function () {
-    const crdt = db._crdt
-    equals(crdt._head.length, 1)
-  })
-  it('should write all', async function () {
-    for (let i = 0; i < 10; i++) {
-      const id = `id-${i}`
-      const doc = await db.get(id)
-      assert(doc)
-      equals(doc._id, id)
-      equals(doc.hello, 'world')
-    }
-  })
-  it('should del all', async function () {
-    for (let i = 0; i < 10; i++) {
-      const id = `id-${i}`
-      const ok = await db.del(id)
-      equals(ok.id, id)
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      const e = await (db.get(id)).catch(e => e)
-      matches(e.message, /Not found/)
-    }
-  })
-  it('should delete all in parallel', async function () {
-    const deletes = []
-    for (let i = 0; i < 10; i++) {
-      const id = `id-${i}`
-      deletes.push(db.del(id))
-    }
-    await Promise.all(deletes)
-    for (let i = 0; i < 10; i++) {
-      const id = `id-${i}`
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      const e = await (db.get(id)).catch(e => e)
-      matches(e.message, /Not found/)
-    }
-  })
-  it('has changes', async function () {
-    const { rows } = await db.changes([])
-    equals(rows.length, 10)
-    for (let i = 0; i < 10; i++) {
-      equals(rows[i].key, 'id-' + i)
-    }
-  })
-})

package/test/fireproof.test.js

@@ -1,50 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import { assert, equals, notEquals, matches, equalsJSON, resetDirectory } from './helpers.js'
-
-import { Fireproof } from '../dist/fireproof.esm.js'
-import { Database } from '../dist/database.esm.js'
-import { CarStoreFS, defaultConfig, HeaderStoreFS } from '../dist/store-fs.esm.js'
-
-describe('Reopening a database', function () {
-  /** @type {Database} */
-  let db
-  beforeEach(async function () {
-    // erase the existing test data
-    await resetDirectory(defaultConfig.dataDir, 'test-reopen')
-
-    db = Fireproof.storage('test-reopen')
-    const ok = await db.put({ _id: 'test', foo: 'bar' })
-    assert(ok)
-    equals(ok.id, 'test')
-
-    assert(db._crdt._head)
-    equals(db._crdt._head.length, 1)
-  })
-
-  it('should persist data', async function () {
-    const doc = await db.get('test')
-    equals(doc.foo, 'bar')
-  })
-
-  it('should have the same data on reopen', async function () {
-    const db2 = Fireproof.storage('test-reopen')
-    const doc = await db2.get('test')
-    equals(doc.foo, 'bar')
-    assert(db2._crdt._head)
-    equals(db2._crdt._head.length, 1)
-    equalsJSON(db2._crdt._head, db._crdt._head)
-  })
-
-  it.skip('passing slow, should have the same data on reopen after reopen and update', async function () {
-    for (let i = 0; i < 100; i++) {
-      const db = Fireproof.storage('test-reopen')
-      const ok = await db.put({ _id: `test${i}`, fire: 'proof'.repeat(50 * 1024) })
-      assert(ok)
-      const doc = await db.get(`test${i}`)
-      equals(doc.fire, 'proof'.repeat(50 * 1024))
-    }
-  }).timeout(20000)
-})

package/test/globals.d.ts

@@ -1,4 +0,0 @@
-declare global {
-  function describe(description: string, callback: () => void): void;
-  function it(description: string, callback: () => void): void;
-}

package/test/hello.test.js

@@ -1,9 +0,0 @@
-import assert from 'assert'
-import { Fireproof } from '../dist/fireproof.esm.js'
-
-describe('Hello World Test', function () {
-  it('should pass the hello world test', function () {
-    const result = Fireproof.storage('hello') // call to your library function
-    assert(result.name === 'hello')
-  })
-})

package/test/helpers.js

@@ -1,34 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-import assert from 'assert'
-// import { join, dirname } from 'node:path'
-// import { mkdir, readdir, rm } from 'fs/promises'
-
-export { assert }
-
-export function equals(actual, expected) {
-  assert(actual === expected, `Expected '${actual}' to equal '${expected}'`)
-}
-
-export function equalsJSON(actual, expected) {
-  equals(JSON.stringify(actual), JSON.stringify(expected))
-}
-
-export function notEquals(actual, expected) {
-  assert(actual !== expected, `Expected '${actual} 'to not equal '${expected}'`)
-}
-
-export function matches(actual, expected) {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
-  assert(actual.toString().match(expected), `Expected '${actual}' to match ${expected}`)
-}
-
-export async function resetDirectory(dir, name) {
-  const path = join(dir, name)
-  await mkdir(path, { recursive: true })
-
-  const files = await readdir(path)
-
-  for (const file of files) {
-    await rm(join(path, file), { recursive: false, force: true })
-  }
-}

package/test/loader.test.js

@@ -1,112 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable mocha/max-top-level-suites */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import { assert, matches, equals, resetDirectory, notEquals } from './helpers.js'
-
-import { parseCarFile } from '../dist/loader-helpers.esm.js'
-
-import { Loader } from '../dist/loader.esm.js'
-import { CRDT } from '../dist/crdt.esm.js'
-import { TransactionBlockstore as Blockstore } from '../dist/transaction.esm.js'
-
-import { defaultConfig } from '../dist/store-fs.esm.js'
-
-describe('Loader with a committed transaction', function () {
-  /** @type {Loader} */
-  let loader, blockstore, crdt, done
-  const dbname = 'test-loader'
-  beforeEach(async function () {
-    await resetDirectory(defaultConfig.dataDir, 'test-loader')
-    loader = new Loader(dbname)
-    blockstore = new Blockstore(dbname, loader)
-    crdt = new CRDT(dbname, blockstore)
-    done = await crdt.bulk([{ key: 'foo', value: { foo: 'bar' } }])
-  })
-  it('should have a name', function () {
-    equals(loader.name, dbname)
-  })
-  it('should commit a transaction', function () {
-    assert(done.head)
-    assert(done.car)
-    equals(blockstore.transactions.size, 1)
-    equals(loader.carLog.length, 1)
-  })
-  it('can load the car', async function () {
-    const reader = await loader.loadCar(done.car)
-    assert(reader)
-    const parsed = await parseCarFile(reader)
-    assert(parsed.cars)
-    equals(parsed.cars.length, 0)
-    assert(parsed.head)
-  })
-})
-
-describe('Loader with two committed transactions', function () {
-  /** @type {Loader} */
-  let loader, blockstore, crdt, done1, done2
-  const dbname = 'test-loader'
-  beforeEach(async function () {
-    await resetDirectory(defaultConfig.dataDir, 'test-loader')
-    loader = new Loader(dbname)
-    blockstore = new Blockstore(dbname, loader)
-    crdt = new CRDT(dbname, blockstore)
-    done1 = await crdt.bulk([{ key: 'apple', value: { foo: 'bar' } }])
-    done2 = await crdt.bulk([{ key: 'orange', value: { foo: 'bar' } }])
-  })
-  it('should commit two transactions', function () {
-    assert(done1.head)
-    assert(done1.car)
-    assert(done2.head)
-    assert(done2.car)
-    notEquals(done1.head, done2.head)
-    notEquals(done1.car, done2.car)
-    equals(blockstore.transactions.size, 2)
-    equals(loader.carLog.length, 2)
-    equals(loader.carLog.indexOf(done1.car), 0)
-    equals(loader.carLog.indexOf(done2.car), 1)
-  })
-  it('can load the car', async function () {
-    const reader = await loader.loadCar(done2.car)
-    assert(reader)
-    const parsed = await parseCarFile(reader)
-    assert(parsed.cars)
-    equals(parsed.cars.length, 1)
-    assert(parsed.head)
-  })
-})
-
-describe('Loader with many committed transactions', function () {
-  /** @type {Loader} */
-  let loader, blockstore, crdt
-  const dbname = 'test-loader'
-  const dones = []
-  const count = 10
-  beforeEach(async function () {
-    await resetDirectory(defaultConfig.dataDir, 'test-loader')
-    loader = new Loader(dbname)
-    blockstore = new Blockstore(dbname, loader)
-    crdt = new CRDT(dbname, blockstore)
-    for (let i = 0; i < count; i++) {
-      const did = await crdt.bulk([{ key: `apple${i}`, value: { foo: 'bar' } }])
-      dones.push(did)
-    }
-  })
-  it('should commit many transactions', function () {
-    for (const done of dones) {
-      assert(done.head)
-      assert(done.car)
-    }
-    equals(blockstore.transactions.size, count)
-    equals(loader.carLog.length, count)
-  })
-  it('can load the car', async function () {
-    const reader = await loader.loadCar(dones[5].car)
-    assert(reader)
-    const parsed = await parseCarFile(reader)
-    assert(parsed.cars)
-    equals(parsed.cars.length, 5)
-    assert(parsed.head)
-  })
-})