hypercore-storage 0.0.40 → 1.0.0

package/lib/memory-overlay.js

@@ -1,438 +0,0 @@
-const { ASSERTION } = require('hypercore-errors')
-const { Readable, isEnded, getStreamError } = require('streamx')
-
-const TipList = require('./tip-list')
-
-class OverlayStream extends Readable {
-  constructor (tip, storage, createStream, opts = {}) {
-    super()
-
-    this.tip = tip
-    this.storage = storage
-    this.options = opts
-
-    this._reverse = !!opts.reverse
-    this._active = null
-    this._position = this._reverse ? tip.length() - 1 : tip.offset
-
-    this._createStream = createStream
-    this._pendingDestroy = null
-
-    if (!opts.reverse) this._makeActiveStream()
-  }
-
-  _predestroy () {
-    if (this._active) this._active.destroy()
-  }
-
-  _read (cb) {
-    if (this._active === null) {
-      if (this._yield()) {
-        cb(null)
-        return
-      }
-    }
-
-    if (this._active) {
-      this._active.resume()
-    }
-
-    cb(null)
-  }
-
-  _yield () {
-    while (this._memoryRemaining()) {
-      const { valid, value } = this.tip.get(this._position)
-      const index = this._nextIndex()
-
-      if (!valid) continue
-      if (!this.push({ index, page: value })) break
-    }
-
-    return this._onmemorydrain()
-  }
-
-  _nextIndex () {
-    if (this._reverse) return this._position--
-    return this._position++
-  }
-
-  _memoryRemaining () {
-    if (this._reverse) return this._position >= this.tip.offset
-    return this._position < this.tip.length()
-  }
-
-  _onmemorydrain () {
-    if (!this._reverse) {
-      this.push(null)
-      return true
-    }
-
-    this._makeActiveStream()
-
-    return false
-  }
-
-  _makeActiveStream () {
-    this._active = this._createStream(this.storage, this.options)
-    this._active.on('error', noop) // handled in onclose
-    this._active.on('close', this._onclose.bind(this))
-    this._active.on('data', this._ondata.bind(this))
-  }
-
-  _ondata (data) {
-    if (!this.push(data)) this._active.pause()
-  }
-
-  _onclose () {
-    if (!isEnded(this._active)) {
-      const error = getStreamError(this._active)
-      this.destroy(error)
-      return
-    }
-
-    if (this._reverse) {
-      this.push(null)
-      return
-    }
-
-    this._yield()
-  }
-}
-
-class MemoryOverlay {
-  constructor (storage) {
-    this.storage = storage
-    this.head = null
-    this.auth = null
-    this.localKeyPair = null
-    this.encryptionKey = null
-    this.dataDependency = null
-    this.dataInfo = null
-    this.userData = null
-    this.blocks = null
-    this.treeNodes = null
-    this.bitfields = null
-
-    this.snapshotted = false
-    this.snapshotShared = null
-    this.activeSnapshots = 0
-    this.copied = false
-  }
-
-  async registerBatch (name, length, overwrite) {
-    todo()
-  }
-
-  snapshot () {
-    if (this.snapshotShared !== null) return this.snapshotShared.snapshot()
-
-    this.activeSnapshots++
-
-    const snap = new MemoryOverlay(this.storage.snapshot())
-
-    snap.snapshotted = true
-    snap.snapshotShared = this
-
-    if (this.head !== null) snap.head = this.head
-    if (this.auth !== null) snap.auth = this.auth
-    if (this.localKeyPair !== null) snap.localKeyPair = this.localKeyPair
-    if (this.encryptionKey !== null) snap.encryptionKey = this.encryptionKey
-    if (this.dataDependency !== null) snap.dataDependency = this.dataDependency
-    if (this.dataInfo !== null) snap.dataInfo = this.dataInfo
-    if (this.userData !== null) snap.userData = this.userData
-    if (this.blocks !== null) snap.blocks = this.blocks
-    if (this.treeNodes !== null) snap.treeNodes = this.treeNodes
-    if (this.bitfields !== null) snap.bitfields = this.bitfields
-
-    return snap
-  }
-
-  _copy () {
-    if (this.copied) return
-    this.copied = true
-
-    // clone state
-    if (this.head !== null) this.head = Object.assign(this.head)
-    if (this.auth !== null) this.auth = Object.assign(this.auth)
-    if (this.localKeyPair !== null) this.localKeyPair = Object.assign(this.localKeyPair)
-    if (this.encryptionKey !== null) this.encryptionKey = Object.assign(this.encryptionKey)
-    if (this.dataDependency !== null) this.dataDependency = Object.assign(this.dataDependency)
-    if (this.dataInfo !== null) this.dataInfo = Object.assign(this.dataInfo)
-    if (this.userData !== null) this.userData = mergeMap(new Map(), this.userData)
-    if (this.blocks !== null) this.blocks = mergeTip(new TipList(), this.blocks)
-    if (this.treeNodes !== null) this.treeNodes = mergeMap(new Map(), this.treeNodes)
-    if (this.bitfields !== null) this.bitfields = mergeTip(new TipList(), this.bitfields)
-  }
-
-  get dependencies () {
-    return this.storage.dependencies
-  }
-
-  dependencyLength () {
-    if (this.dataDependency) return this.dataDependency.length
-    return this.storage.dependencyLength()
-  }
-
-  createReadBatch () {
-    return new MemoryOverlayReadBatch(this, this.storage.createReadBatch())
-  }
-
-  createWriteBatch () {
-    if (this.activeSnapshots > 0) this._copy()
-    return new MemoryOverlayWriteBatch(this)
-  }
-
-  createBlockStream () {
-    todo()
-  }
-
-  createUserDataStream () {
-    todo()
-  }
-
-  createTreeNodeStream () {
-    todo()
-  }
-
-  createBitfieldPageStream (opts) {
-    if (this.bitfields === null) return createBitfieldPageStream(this.storage)
-    return new OverlayStream(this.bitfields, this.storage, createBitfieldPageStream, opts)
-  }
-
-  findDependency () {
-    return null
-  }
-
-  async peekLastTreeNode () {
-    todo()
-  }
-
-  async peekLastBitfieldPage () {
-    const mem = this.bitfields !== null ? this.bitfields.get(this.bitfields.length() - 1) : { valid: false }
-
-    const page = mem.valid ? mem.value : null
-    const index = page ? this.bitfields.length() - 1 : -1
-
-    const disk = await this.storage.peekLastBitfieldPage()
-
-    return (page && (!disk || index > disk.index)) ? { index, page } : disk
-  }
-
-  destroy () {
-    if (this.snapshotted) this.storage.destroy()
-    if (this.snapshotShared === null) return
-    this.snapshotShared.activeSnapshots--
-    this.snapshotShared = null
-  }
-
-  merge (overlay) {
-    if (overlay.head !== null) this.head = overlay.head
-    if (overlay.auth !== null) this.auth = overlay.auth
-    if (overlay.localKeyPair !== null) this.localKeyPair = overlay.localKeyPair
-    if (overlay.encryptionKey !== null) this.encryptionKey = overlay.encryptionKey
-    if (overlay.dataDependency !== null) this.dataDependency = overlay.dataDependency
-    if (overlay.dataInfo !== null) this.dataInfo = overlay.dataInfo
-    if (overlay.userData !== null) this.userData = mergeMap(this.userData, overlay.userData)
-    if (overlay.blocks !== null) this.blocks = mergeTip(this.blocks, overlay.blocks)
-    if (overlay.treeNodes !== null) this.treeNodes = mergeMap(this.treeNodes, overlay.treeNodes)
-    if (overlay.bitfields !== null) this.bitfields = mergeTip(this.bitfields, overlay.bitfields)
-  }
-}
-
-module.exports = MemoryOverlay
-
-class MemoryOverlayReadBatch {
-  constructor (overlay, read) {
-    this.read = read
-    this.overlay = overlay
-  }
-
-  async getCoreHead () {
-    return this.overlay.head !== null ? this.overlay.head : this.read.getCoreHead()
-  }
-
-  async getCoreAuth () {
-    return this.overlay.auth !== null ? this.overlay.auth : this.read.getCoreAuth()
-  }
-
-  async getDataDependency () {
-    return this.overlay.dataDependency !== null ? this.overlay.dataDependency : this.read.getDataDependency()
-  }
-
-  async getLocalKeyPair () {
-    return this.overlay.localKeyPair !== null ? this.overlay.localKeyPair : this.read.getLocalKeyPair()
-  }
-
-  async getEncryptionKey () {
-    return this.overlay.encryptionKey !== null ? this.overlay.encryptionKey : this.read.getEncryptionKey()
-  }
-
-  async getDataInfo () {
-    return this.overlay.dataInfo !== null ? this.overlay.dataInfo : this.read.getDataInfo()
-  }
-
-  async getUserData (key) {
-    return this.overlay.userData !== null && this.overlay.userData.has(key)
-      ? this.overlay.userData.get(key)
-      : this.read.getUserData(key)
-  }
-
-  async hasBlock (index) {
-    if (this.overlay.blocks !== null && index >= this.overlay.blocks.offset) {
-      const blk = this.overlay.blocks.get(index)
-      if (blk.valid) return true
-    }
-    return this.read.hasBlock(index)
-  }
-
-  async getBlock (index, error) {
-    if (this.overlay.blocks !== null && index >= this.overlay.blocks.offset) {
-      const blk = this.overlay.blocks.get(index)
-      if (blk.valid) return blk.value
-    }
-    return this.read.getBlock(index, error)
-  }
-
-  async hasTreeNode (index) {
-    return this.overlay.treeNodes !== null
-      ? this.overlay.treeNodes.has(index)
-      : this.read.hasTreeNode(index)
-  }
-
-  async getTreeNode (index, error) {
-    return this.overlay.treeNodes !== null && this.overlay.treeNodes.has(index)
-      ? this.overlay.treeNodes.get(index)
-      : this.read.getTreeNode(index, error)
-  }
-
-  async getBitfieldPage (index) {
-    if (this.overlay.bitfields !== null && index >= this.overlay.bitfields.offset) {
-      const page = this.overlay.bitfields.get(index)
-      if (page.valid) return page.value
-    }
-    return this.read.getBitfieldPage(index)
-  }
-
-  destroy () {
-    this.read.destroy()
-  }
-
-  flush () {
-    return this.read.flush()
-  }
-
-  tryFlush () {
-    this.read.tryFlush()
-  }
-}
-
-class MemoryOverlayWriteBatch {
-  constructor (storage) {
-    this.storage = storage
-    this.overlay = new MemoryOverlay()
-  }
-
-  setCoreHead (head) {
-    this.overlay.head = head
-  }
-
-  setCoreAuth (auth) {
-    this.overlay.auth = auth
-  }
-
-  setBatchPointer (name, pointer) {
-    todo()
-  }
-
-  setDataDependency (dependency) {
-    this.overlay.dataDependency = dependency
-  }
-
-  setLocalKeyPair (keyPair) {
-    this.overlay.localKeyPair = keyPair
-  }
-
-  setEncryptionKey (encryptionKey) {
-    this.overlay.encryptionKey = encryptionKey
-  }
-
-  setDataInfo (info) {
-    this.overlay.dataInfo = info
-  }
-
-  setUserData (key, value) {
-    if (this.overlay.userData === null) this.overlay.userData = new Map()
-    this.overlay.userData.set(key, value)
-  }
-
-  putBlock (index, data) {
-    if (this.overlay.blocks === null) this.overlay.blocks = new TipList()
-    this.overlay.blocks.put(index, data)
-  }
-
-  deleteBlock (index) {
-    todo()
-  }
-
-  deleteBlockRange (start, end) {
-    if (this.overlay.blocks === null) this.overlay.blocks = new TipList()
-    this.overlay.blocks.delete(start, end)
-  }
-
-  putTreeNode (node) {
-    if (this.overlay.treeNodes === null) this.overlay.treeNodes = new Map()
-    this.overlay.treeNodes.set(node.index, node)
-  }
-
-  deleteTreeNode (index) {
-    todo()
-  }
-
-  deleteTreeNodeRange (start, end) {
-    todo()
-  }
-
-  putBitfieldPage (index, page) {
-    if (this.overlay.bitfields === null) this.overlay.bitfields = new TipList()
-    this.overlay.bitfields.put(index, page)
-  }
-
-  deleteBitfieldPage (index) {
-    todo()
-  }
-
-  deleteBitfieldPageRange (start, end) {
-    if (this.overlay.bitfields === null) this.overlay.bitfields = new TipList()
-    this.overlay.bitfields.delete(start, end)
-  }
-
-  destroy () {}
-
-  flush () {
-    this.storage.merge(this.overlay)
-    return Promise.resolve()
-  }
-}
-
-function createBitfieldPageStream (storage, opts) {
-  return storage.createBitfieldPageStream(opts)
-}
-
-function mergeMap (a, b) {
-  if (a === null) return b
-  for (const [key, value] of b) a.set(key, value)
-  return a
-}
-
-function mergeTip (a, b) {
-  if (a === null) return b
-  a.merge(b)
-  return a
-}
-
-function noop () {}
-
-function todo () {
-  throw ASSERTION('Not supported yet, but will be')
-}

package/lib/messages.js

@@ -1,190 +0,0 @@
-const c = require('compact-encoding')
-
-exports.DataPointer = c.uint
-
-exports.KeyPair = {
-  preencode (state, m) {
-    c.uint.preencode(state, m.secretKey ? 1 : 0)
-    c.fixed32.preencode(state, m.publicKey)
-    if (m.secretKey) c.fixed64.preencode(state, m.secretKey)
-  },
-  encode (state, m) {
-    c.uint.encode(state, m.secretKey ? 1 : 0)
-    c.fixed32.encode(state, m.publicKey)
-    if (m.secretKey) c.fixed64.encode(state, m.secretKey)
-  },
-  decode (state) {
-    const flags = c.uint.decode(state)
-
-    return {
-      publicKey: c.fixed32.decode(state),
-      secretKey: flags & 1 ? c.fixed64.decode(state) : null
-    }
-  }
-}
-
-exports.StorageInfo = {
-  preencode (state, m) {
-    c.uint.preencode(state, 0) // version
-    c.uint.preencode(state, 0) // flags, reserved
-    c.uint.preencode(state, m.free)
-    c.uint.preencode(state, m.total)
-  },
-  encode (state, m) {
-    c.uint.encode(state, 0) // version
-    c.uint.encode(state, 0) // flags, reserved
-    c.uint.encode(state, m.free)
-    c.uint.encode(state, m.total)
-  },
-  decode (state, m) {
-    const v = c.uint.decode(state)
-    if (v !== 0) throw new Error('Invalid version: ' + v)
-
-    c.uint.decode(state) // flags, ignore
-
-    return {
-      free: c.uint.decode(state),
-      total: c.uint.decode(state)
-    }
-  }
-}
-
-exports.CorePointer = {
-  preencode (state, m) {
-    c.uint.preencode(state, m.core)
-    c.uint.preencode(state, m.data)
-  },
-  encode (state, m) {
-    c.uint.encode(state, m.core)
-    c.uint.encode(state, m.data)
-  },
-  decode (state) {
-    return {
-      core: c.uint.decode(state),
-      data: c.uint.decode(state)
-    }
-  }
-}
-
-exports.CoreHead = {
-  preencode (state, m) {
-    c.uint.preencode(state, m.fork)
-    c.uint.preencode(state, m.length)
-    c.fixed32.preencode(state, m.rootHash)
-    c.buffer.preencode(state, m.signature)
-  },
-  encode (state, m) {
-    c.uint.encode(state, m.fork)
-    c.uint.encode(state, m.length)
-    c.fixed32.encode(state, m.rootHash)
-    c.buffer.encode(state, m.signature)
-  },
-  decode (state) {
-    return {
-      fork: c.uint.decode(state),
-      length: c.uint.decode(state),
-      rootHash: c.fixed32.decode(state),
-      signature: c.buffer.decode(state)
-    }
-  }
-}
-
-exports.TreeNode = {
-  preencode (state, m) {
-    c.uint.preencode(state, m.index)
-    c.uint.preencode(state, m.size)
-    c.fixed32.preencode(state, m.hash)
-  },
-  encode (state, m) {
-    c.uint.encode(state, m.index)
-    c.uint.encode(state, m.size)
-    c.fixed32.encode(state, m.hash)
-  },
-  decode (state) {
-    return {
-      index: c.uint.decode(state),
-      size: c.uint.decode(state),
-      hash: c.fixed32.decode(state)
-    }
-  }
-}
-
-exports.CoreAuth = {
-  preencode (state, m) {
-    c.uint.preencode(state, m.manifest ? 1 : 0)
-    c.fixed32.preencode(state, m.key)
-    if (m.manifest) c.buffer.preencode(state, m.manifest)
-  },
-  encode (state, m) {
-    c.uint.encode(state, m.manifest ? 1 : 0)
-    c.fixed32.encode(state, m.key)
-    if (m.manifest) c.buffer.encode(state, m.manifest)
-  },
-  decode (state) {
-    const flags = c.uint.decode(state)
-
-    return {
-      key: c.fixed32.decode(state),
-      manifest: flags & 1 ? c.buffer.decode(state) : null
-    }
-  }
-}
-
-exports.DataDependency = {
-  preencode (state, m) {
-    c.uint.preencode(state, m.data)
-    c.uint.preencode(state, m.length)
-  },
-  encode (state, m) {
-    c.uint.encode(state, m.data)
-    c.uint.encode(state, m.length)
-  },
-  decode (state) {
-    return {
-      data: c.uint.decode(state),
-      length: c.uint.decode(state)
-    }
-  }
-}
-
-exports.CoreSeed = {
-  preencode (state, m) {
-    c.fixed32.preencode(state, m.seed)
-  },
-  encode (state, m) {
-    c.fixed32.encode(state, m.seed)
-  },
-  decode (state) {
-    return {
-      seed: c.fixed32.decode(state)
-    }
-  }
-}
-
-exports.CoreEncryptionKey = {
-  preencode (state, m) {
-    c.fixed32.preencode(state, m.encryptionKey)
-  },
-  encode (state, m) {
-    c.fixed32.encode(state, m.encryptionKey)
-  },
-  decode (state) {
-    return {
-      encryptionKey: c.fixed32.decode(state)
-    }
-  }
-}
-
-exports.DataInfo = {
-  preencode (state, m) {
-    c.uint.preencode(state, m.version)
-  },
-  encode (state, m) {
-    c.uint.encode(state, m.version)
-  },
-  decode (state) {
-    return {
-      version: c.uint.decode(state)
-    }
-  }
-}

package/lib/tip-list.js

@@ -1,93 +0,0 @@
-const { ASSERTION } = require('hypercore-errors')
-
-module.exports = class TipList {
-  constructor () {
-    this.offset = 0
-    this.removed = 0
-    this.data = []
-  }
-
-  length () {
-    return this.offset + this.data.length
-  }
-
-  end () {
-    if (this.removed) return this.removed
-    return this.offset + this.data.length
-  }
-
-  delete (start, end) {
-    if (end !== -1) {
-      if (end < this.length() || (this.length() < start && this.length() !== 0)) {
-        throw ASSERTION('Invalid delete on tip list')
-      }
-    }
-
-    if (this.end() === 0) this.offset = start
-    if (this.removed < end || end === -1) this.removed = end
-
-    if (start < this.offset) {
-      this.offset = start
-      this.data = [] // clear everything
-      return
-    }
-
-    while (this.length() > start) this.data.pop()
-  }
-
-  put (index, value) {
-    if (this.end() === 0) {
-      this.offset = index
-      this.data.push(value)
-      return
-    }
-
-    if (!this.removed && this.end() === index) {
-      this.data.push(value)
-      return
-    }
-
-    throw ASSERTION('Invalid put on tip list')
-  }
-
-  get (index) {
-    if (index < this.offset) {
-      return {
-        valid: false,
-        value: null
-      }
-    }
-
-    if (index - this.offset < this.data.length) {
-      return {
-        valid: true,
-        value: this.data[index - this.offset]
-      }
-    }
-
-    return {
-      valid: index < this.end(),
-      value: null
-    }
-  }
-
-  * [Symbol.iterator] () {
-    for (let i = 0; i < this.data.length; i++) {
-      yield [i + this.offset, this.data[i]]
-    }
-  }
-
-  merge (tip) {
-    const invalidDeletion = tip.removed > 0 && tip.end() !== -1 && tip.end() < this.end()
-    const invalidTip = (tip.removed !== -1 && tip.end() < this.offset) || this.end() < tip.offset
-
-    if (invalidTip || invalidDeletion) throw ASSERTION('Cannot merge tip list')
-
-    while (this.end() !== tip.offset && tip.offset >= this.offset && tip.end() >= this.end()) this.data.pop()
-    while (tip.removed && this.end() > tip.length() && this.data.length) this.data.pop()
-
-    for (const data of tip.data) this.data.push(data)
-
-    return this
-  }
-}