hypercore-storage 1.16.0 → 1.18.0

package/lib/block-dependency-stream.js

@@ -2,7 +2,7 @@ const { Readable, getStreamError } = require('streamx')
 const { core } = require('./keys')
 
 module.exports = class BlockStream extends Readable {
-  constructor (core, db, updates, start, end, reverse) {
+  constructor(core, db, updates, start, end, reverse) {
     super()
 
     this.core = core
@@ -21,24 +21,24 @@ module.exports = class BlockStream extends Readable {
     this._update()
   }
 
-  _update () {
+  _update() {
     if (this._consumed > this.core.dependencies.length) return
 
     const deps = this.core.dependencies
     const index = this._findDependencyIndex(deps)
 
     const curr = index < deps.length ? deps[index] : null
-    const prev = (index > 0 && index - 1 < deps.length) ? deps[index - 1] : null
+    const prev = index > 0 && index - 1 < deps.length ? deps[index - 1] : null
 
-    const start = (prev && prev.length > this.start) ? prev.length : this.start
-    const end = (curr && (this.end === -1 || curr.length < this.end)) ? curr.length : this.end
+    const start = prev && prev.length > this.start ? prev.length : this.start
+    const end = curr && (this.end === -1 || curr.length < this.end) ? curr.length : this.end
 
     const ptr = curr ? curr.dataPointer : this.core.dataPointer
 
     this._makeStream(core.block(ptr, start), core.block(ptr, end))
   }
 
-  _findDependencyIndex (deps) {
+  _findDependencyIndex(deps) {
     if (!this.reverse) return this._consumed++
 
     let i = deps.length - this._consumed++
@@ -51,21 +51,21 @@ module.exports = class BlockStream extends Readable {
     return 0
   }
 
-  _predestroy () {
+  _predestroy() {
     if (this._stream !== null) this._stream.destroy()
   }
 
-  _read (cb) {
+  _read(cb) {
     this._drained = this._onreadable()
     cb(null)
   }
 
-  _maybeDrain () {
+  _maybeDrain() {
     if (this._drained === true) return
     this._drained = this._onreadable()
   }
 
-  _onreadable () {
+  _onreadable() {
     if (this._stream === null) {
       this.push(null)
       return true
@@ -83,7 +83,7 @@ module.exports = class BlockStream extends Readable {
     return true
   }
 
-  _onclose () {
+  _onclose() {
     if (this.destroying) return
 
     const err = getStreamError(this._stream)
@@ -102,7 +102,7 @@ module.exports = class BlockStream extends Readable {
     this._maybeDrain()
   }
 
-  _makeStream (start, end) {
+  _makeStream(start, end) {
     this._stream = this.updates.iterator(this.db, start, end, this.reverse)
     this._stream.on('readable', this._maybeDrainBound)
     this._stream.on('error', noop)
@@ -110,4 +110,4 @@ module.exports = class BlockStream extends Readable {
   }
 }
 
-function noop () {}
+function noop() {}

package/lib/close-error-stream.js

@@ -3,12 +3,12 @@ const { Readable } = require('streamx')
 // used for returned a stream that just errors (during read during teardown)
 
 module.exports = class CloseErrorStream extends Readable {
-  constructor (err) {
+  constructor(err) {
     super()
     this.error = err
   }
 
-  _open (cb) {
+  _open(cb) {
     cb(this.error)
   }
 }

package/lib/keys.js

@@ -283,7 +283,7 @@ core.localKey = function (buffer) {
 
 module.exports = { store, core }
 
-function alloc () {
+function alloc() {
   if (slab.buffer.byteLength - slab.start < 4096) {
     slab.buffer = b4a.allocUnsafe(slab.buffer.byteLength)
     slab.start = 0

package/lib/streams.js

@@ -18,7 +18,7 @@ module.exports = {
   createLocalStream
 }
 
-function createCoreStream (db, view) {
+function createCoreStream(db, view) {
   const start = store.coreStart()
   const end = store.coreEnd()
 
@@ -28,7 +28,7 @@ function createCoreStream (db, view) {
   return ite
 }
 
-function createDiscoveryKeyStream (db, view, namespace) {
+function createDiscoveryKeyStream(db, view, namespace) {
   const start = namespace ? store.coreByAliasStart(namespace) : store.coreStart()
   const end = namespace ? store.coreByAliasEnd(namespace) : store.coreEnd()
 
@@ -38,7 +38,7 @@ function createDiscoveryKeyStream (db, view, namespace) {
   return ite
 }
 
-function createAliasStream (db, view, namespace) {
+function createAliasStream(db, view, namespace) {
   const start = store.coreByAliasStart(namespace)
   const end = store.coreByAliasEnd(namespace)
 
@@ -48,7 +48,7 @@ function createAliasStream (db, view, namespace) {
   return ite
 }
 
-function createBlockIterator (ptr, db, view, start, end, reverse) {
+function createBlockIterator(ptr, db, view, start, end, reverse) {
   if (ptr.dependencies.length > 0) {
     return new BlockDependencyStream(ptr, db, view, start, end, reverse)
   }
@@ -58,14 +58,24 @@ function createBlockIterator (ptr, db, view, start, end, reverse) {
   return view.iterator(db, s, e, reverse)
 }
 
-function createBlockStream (ptr, db, view, { gt = -1, gte = gt + 1, lte = -1, lt = lte === -1 ? -1 : lte + 1, reverse = false } = {}) {
+function createBlockStream(
+  ptr,
+  db,
+  view,
+  { gt = -1, gte = gt + 1, lte = -1, lt = lte === -1 ? -1 : lte + 1, reverse = false } = {}
+) {
   const ite = createBlockIterator(ptr, db, view, gte, lt, reverse)
 
   ite._readableState.map = mapBlock
   return ite
 }
 
-function createBitfieldStream (ptr, db, view, { gt = -1, gte = gt + 1, lte = -1, lt = lte === -1 ? -1 : lte + 1, reverse = false } = {}) {
+function createBitfieldStream(
+  ptr,
+  db,
+  view,
+  { gt = -1, gte = gt + 1, lte = -1, lt = lte === -1 ? -1 : lte + 1, reverse = false } = {}
+) {
   const s = core.bitfield(ptr.dataPointer, gte, 0)
   const e = core.bitfield(ptr.dataPointer, lt === -1 ? Infinity : lt, 0)
   const ite = view.iterator(db, s, e, false)
@@ -75,7 +85,12 @@ function createBitfieldStream (ptr, db, view, { gt = -1, gte = gt + 1, lte = -1,
 }
 
 // NOTE: this does not do dependency lookups atm
-function createTreeNodeStream (ptr, db, view, { gt = -1, gte = gt + 1, lte = -1, lt = lte === -1 ? -1 : lte + 1, reverse = false } = {}) {
+function createTreeNodeStream(
+  ptr,
+  db,
+  view,
+  { gt = -1, gte = gt + 1, lte = -1, lt = lte === -1 ? -1 : lte + 1, reverse = false } = {}
+) {
   const s = core.tree(ptr.dataPointer, gte, 0)
   const e = core.tree(ptr.dataPointer, lt === -1 ? Infinity : lt, 0)
   const ite = view.iterator(db, s, e, false)
@@ -84,8 +99,14 @@ function createTreeNodeStream (ptr, db, view, { gt = -1, gte = gt + 1, lte = -1,
   return ite
 }
 
-function createUserDataStream (ptr, db, view, { gt = null, gte = '', lte = null, lt = null, reverse = false } = {}) {
-  if (gt !== null || lte !== null) throw new Error('gt and lte not yet supported for user data streams')
+function createUserDataStream(
+  ptr,
+  db,
+  view,
+  { gt = null, gte = '', lte = null, lt = null, reverse = false } = {}
+) {
+  if (gt !== null || lte !== null)
+    throw new Error('gt and lte not yet supported for user data streams')
 
   const s = core.userData(ptr.dataPointer, gte)
   const e = lt === null ? core.userDataEnd(ptr.dataPointer) : core.userData(ptr.dataPointer, lt)
@@ -95,7 +116,12 @@ function createUserDataStream (ptr, db, view, { gt = null, gte = '', lte = null,
   return ite
 }
 
-function createLocalStream (ptr, db, view, { gt = null, gte = EMPTY, lte = null, lt = null, reverse = false } = {}) {
+function createLocalStream(
+  ptr,
+  db,
+  view,
+  { gt = null, gte = EMPTY, lte = null, lt = null, reverse = false } = {}
+) {
   if (gt !== null || lte !== null) throw new Error('gt and lte not yet supported for local streams')
 
   const s = core.local(ptr.dataPointer, gte)
@@ -106,45 +132,53 @@ function createLocalStream (ptr, db, view, { gt = null, gte = EMPTY, lte = null,
   return ite
 }
 
-function mapBitfield (data) {
+function mapBitfield(data) {
   const [index, type] = core.bitfieldIndexAndType(data.key)
   if (type !== 0) return null // ignore for now
   return { index, page: data.value }
 }
 
-function mapLocal (data) {
+function mapLocal(data) {
   const key = core.localKey(data.key)
   return { key, value: data.value }
 }
 
-function mapUserData (data) {
+function mapUserData(data) {
   const key = core.userDataKey(data.key)
   return { key, value: data.value }
 }
 
-function mapCore (data) {
+function mapCore(data) {
   const discoveryKey = store.discoveryKey(data.key)
-  const core = CORESTORE_CORE.decode({ start: 0, end: data.value.byteLength, buffer: data.value })
+  const core = CORESTORE_CORE.decode({
+    start: 0,
+    end: data.value.byteLength,
+    buffer: data.value
+  })
   return { discoveryKey, core }
 }
 
-function mapAllDiscoveryKeys (data) {
+function mapAllDiscoveryKeys(data) {
   return store.discoveryKey(data.key)
 }
 
-function mapNamespaceDiscoveryKeys (data) {
+function mapNamespaceDiscoveryKeys(data) {
   return data.value
 }
 
-function mapAlias (data) {
+function mapAlias(data) {
   const alias = store.alias(data.key)
   return { alias, discoveryKey: data.value }
 }
 
-function mapBlock (data) {
+function mapBlock(data) {
   return { index: core.blockIndex(data.key), value: data.value }
 }
 
-function mapTreeNode (data) {
-  return CORE_TREE_NODE.decode({ start: 0, end: data.value.byteLength, buffer: data.value })
+function mapTreeNode(data) {
+  return CORE_TREE_NODE.decode({
+    start: 0,
+    end: data.value.byteLength,
+    buffer: data.value
+  })
 }

package/lib/tx.js

@@ -15,7 +15,7 @@ const CORE_DEPENDENCY = schema.getEncoding('@core/dependency')
 const CORE_HINTS = schema.getEncoding('@core/hints')
 
 class CoreTX {
-  constructor (core, db, view, changes) {
+  constructor(core, db, view, changes) {
     if (db.snapshotted) throw new Error('Cannot open core tx on snapshot')
     this.core = core
     this.db = db
@@ -23,39 +23,39 @@ class CoreTX {
     this.changes = changes
   }
 
-  setAuth (auth) {
+  setAuth(auth) {
     this.changes.push([core.auth(this.core.corePointer), encode(CORE_AUTH, auth), null])
   }
 
-  setSessions (sessions) {
+  setSessions(sessions) {
     this.changes.push([core.sessions(this.core.corePointer), encode(CORE_SESSIONS, sessions), null])
   }
 
-  setHead (head) {
+  setHead(head) {
     this.changes.push([core.head(this.core.dataPointer), encode(CORE_HEAD, head), null])
   }
 
-  deleteHead () {
+  deleteHead() {
     this.changes.push([core.head(this.core.dataPointer), null, null])
   }
 
-  setDependency (dep) {
+  setDependency(dep) {
     this.changes.push([core.dependency(this.core.dataPointer), encode(CORE_DEPENDENCY, dep), null])
   }
 
-  setHints (hints) {
+  setHints(hints) {
     this.changes.push([core.hints(this.core.dataPointer), encode(CORE_HINTS, hints), null])
   }
 
-  putBlock (index, data) {
+  putBlock(index, data) {
     this.changes.push([core.block(this.core.dataPointer, index), data, null])
   }
 
-  deleteBlock (index) {
+  deleteBlock(index) {
     this.changes.push([core.block(this.core.dataPointer, index), null, null])
   }
 
-  deleteBlockRange (start, end) {
+  deleteBlockRange(start, end) {
     this.changes.push([
       core.block(this.core.dataPointer, start),
       null,
@@ -63,15 +63,15 @@ class CoreTX {
     ])
   }
 
-  putBitfieldPage (index, data) {
+  putBitfieldPage(index, data) {
     this.changes.push([core.bitfield(this.core.dataPointer, index, 0), data, null])
   }
 
-  deleteBitfieldPage (index) {
+  deleteBitfieldPage(index) {
     this.changes.push([core.bitfield(this.core.dataPointer, index, 0), null, null])
   }
 
-  deleteBitfieldPageRange (start, end) {
+  deleteBitfieldPageRange(start, end) {
     this.changes.push([
       core.bitfield(this.core.dataPointer, start, 0),
       null,
@@ -79,15 +79,19 @@ class CoreTX {
     ])
   }
 
-  putTreeNode (node) {
-    this.changes.push([core.tree(this.core.dataPointer, node.index), encode(CORE_TREE_NODE, node), null])
+  putTreeNode(node) {
+    this.changes.push([
+      core.tree(this.core.dataPointer, node.index),
+      encode(CORE_TREE_NODE, node),
+      null
+    ])
   }
 
-  deleteTreeNode (index) {
+  deleteTreeNode(index) {
     this.changes.push([core.tree(this.core.dataPointer, index), null, null])
   }
 
-  deleteTreeNodeRange (start, end) {
+  deleteTreeNodeRange(start, end) {
     this.changes.push([
       core.tree(this.core.dataPointer, start),
       null,
@@ -95,24 +99,24 @@ class CoreTX {
     ])
   }
 
-  putUserData (key, value) {
+  putUserData(key, value) {
     const buffer = typeof value === 'string' ? b4a.from(value) : value
     this.changes.push([core.userData(this.core.dataPointer, key), buffer, null])
   }
 
-  deleteUserData (key) {
+  deleteUserData(key) {
     this.changes.push([core.userData(this.core.dataPointer, key), null, null])
   }
 
-  putLocal (key, value) {
+  putLocal(key, value) {
     this.changes.push([core.local(this.core.dataPointer, key), value, null])
   }
 
-  deleteLocal (key) {
+  deleteLocal(key) {
     this.changes.push([core.local(this.core.dataPointer, key), null, null])
   }
 
-  deleteLocalRange (start, end) {
+  deleteLocalRange(start, end) {
     this.changes.push([
       core.local(this.core.dataPointer, start),
       null,
@@ -120,7 +124,7 @@ class CoreTX {
     ])
   }
 
-  flush () {
+  flush() {
     const changes = this.changes
     if (changes === null) return Promise.resolve(!this.view)
 
@@ -136,7 +140,7 @@ class CoreTX {
 }
 
 class CoreRX {
-  constructor (core, db, view) {
+  constructor(core, db, view) {
     this.core = core
     this.read = db.read({ autoDestroy: true })
     this.view = view
@@ -144,65 +148,86 @@ class CoreRX {
     view.readStart()
   }
 
-  async getAuth () {
+  static async getAuth(db, c) {
+    return await decode(CORE_AUTH, await db.get(core.auth(c.corePointer)))
+  }
+
+  async getAuth() {
     return await decode(CORE_AUTH, await this.view.get(this.read, core.auth(this.core.corePointer)))
   }
 
-  async getSessions () {
-    return await decode(CORE_SESSIONS, await this.view.get(this.read, core.sessions(this.core.corePointer)))
+  async getSessions() {
+    return await decode(
+      CORE_SESSIONS,
+      await this.view.get(this.read, core.sessions(this.core.corePointer))
+    )
   }
 
-  async getHead () {
+  static async getHead(db, c) {
+    return await decode(CORE_HEAD, await db.get(core.head(c.dataPointer)))
+  }
+
+  async getHead() {
     return await decode(CORE_HEAD, await this.view.get(this.read, core.head(this.core.dataPointer)))
   }
 
-  async getDependency () {
-    return await decode(CORE_DEPENDENCY, await this.view.get(this.read, core.dependency(this.core.dataPointer)))
+  async getDependency() {
+    return await decode(
+      CORE_DEPENDENCY,
+      await this.view.get(this.read, core.dependency(this.core.dataPointer))
+    )
+  }
+
+  static async getHints(db, c) {
+    return await decode(CORE_HINTS, await db.get(core.head(c.dataPointer)))
   }
 
-  async getHints () {
-    return await decode(CORE_HINTS, await this.view.get(this.read, core.hints(this.core.dataPointer)))
+  async getHints() {
+    return await decode(
+      CORE_HINTS,
+      await this.view.get(this.read, core.hints(this.core.dataPointer))
+    )
   }
 
-  getBlock (index) {
+  getBlock(index) {
     const dep = findBlockDependency(this.core.dependencies, index)
     const data = dep === null ? this.core.dataPointer : dep.dataPointer
     return this.view.get(this.read, core.block(data, index))
   }
 
-  getBitfieldPage (index) {
+  getBitfieldPage(index) {
     return this.view.get(this.read, core.bitfield(this.core.dataPointer, index, 0))
   }
 
-  async getTreeNode (index) {
+  async getTreeNode(index) {
     const dep = findTreeDependency(this.core.dependencies, index)
     const data = dep === null ? this.core.dataPointer : dep.dataPointer
     return decode(CORE_TREE_NODE, await this.view.get(this.read, core.tree(data, index)))
   }
 
-  async hasTreeNode (index) {
+  async hasTreeNode(index) {
     return (await this.getTreeNode(index)) !== null
   }
 
-  getUserData (key) {
+  getUserData(key) {
     return this.view.get(this.read, core.userData(this.core.dataPointer, key))
   }
 
-  getLocal (key) {
+  getLocal(key) {
     return this.view.get(this.read, core.local(this.core.dataPointer, key))
   }
 
-  tryFlush () {
+  tryFlush() {
     this.read.tryFlush()
     this._free()
   }
 
-  destroy () {
+  destroy() {
     this.read.destroy()
     this._free()
   }
 
-  _free () {
+  _free() {
     if (this.view === null) return
     this.view.readStop()
     this.view = null
@@ -210,29 +235,29 @@ class CoreRX {
 }
 
 class CorestoreTX {
-  constructor (view) {
+  constructor(view) {
     this.view = view
     this.changes = []
   }
 
-  setHead (head) {
+  setHead(head) {
     this.changes.push([store.head(), encode(CORESTORE_HEAD, head), null])
   }
 
-  putCore (discoveryKey, ptr) {
+  putCore(discoveryKey, ptr) {
     this.changes.push([store.core(discoveryKey), encode(CORESTORE_CORE, ptr), null])
   }
 
-  putCoreByAlias (alias, discoveryKey) {
+  putCoreByAlias(alias, discoveryKey) {
     this.changes.push([store.coreByAlias(alias), discoveryKey, null])
   }
 
-  clear () {
+  clear() {
     const [start, end] = store.clear()
     this.changes.push([start, null, end])
   }
 
-  apply () {
+  apply() {
     if (this.changes === null) return
     this.view.apply(this.changes)
     this.changes = null
@@ -240,36 +265,36 @@ class CorestoreTX {
 }
 
 class CorestoreRX {
-  constructor (db, view) {
+  constructor(db, view) {
     this.read = db.read({ autoDestroy: true })
     this.view = view
 
     view.readStart()
   }
 
-  async getHead () {
+  async getHead() {
     return decode(CORESTORE_HEAD, await this.view.get(this.read, store.head()))
   }
 
-  async getCore (discoveryKey) {
+  async getCore(discoveryKey) {
     return decode(CORESTORE_CORE, await this.view.get(this.read, store.core(discoveryKey)))
   }
 
-  getCoreByAlias (alias) {
+  getCoreByAlias(alias) {
     return this.view.get(this.read, store.coreByAlias(alias))
   }
 
-  tryFlush () {
+  tryFlush() {
     this.read.tryFlush()
     this._free()
   }
 
-  destroy () {
+  destroy() {
     this.read.destroy()
     this._free()
   }
 
-  _free () {
+  _free() {
     if (this.view === null) return
     this.view.readStop()
     this.view = null
@@ -278,7 +303,7 @@ class CorestoreRX {
 
 module.exports = { CorestoreTX, CorestoreRX, CoreTX, CoreRX }
 
-function findBlockDependency (dependencies, index) {
+function findBlockDependency(dependencies, index) {
   for (let i = 0; i < dependencies.length; i++) {
     const dep = dependencies[i]
     if (index < dep.length) return dep
@@ -287,7 +312,7 @@ function findBlockDependency (dependencies, index) {
   return null
 }
 
-function findTreeDependency (dependencies, index) {
+function findTreeDependency(dependencies, index) {
   for (let i = 0; i < dependencies.length; i++) {
     const dep = dependencies[i]
     if (flat.rightSpan(index) <= (dep.length - 1) * 2) return dep
@@ -296,12 +321,12 @@ function findTreeDependency (dependencies, index) {
   return null
 }
 
-function decode (enc, buffer) {
+function decode(enc, buffer) {
   if (buffer === null) return null
   return enc.decode({ start: 0, end: buffer.byteLength, buffer })
 }
 
-function encode (enc, m) {
+function encode(enc, m) {
   // TODO: use fancy slab for small messages
   const state = { start: 0, end: 0, buffer: null }
   enc.preencode(state, m)