hypercore 10.12.0 → 10.14.0

package/README.md

@@ -303,6 +303,16 @@ To cancel downloading a range simply destroy the range instance.
 range.destroy()
 ```
 
+#### `const session = await core.session([options])`
+
+Creates a new Hypercore instance that shares the same underlying core.
+
+You must close any session you make.
+
+Options are inherited from the parent instance, unless they are re-set.
+
+`options` are the same as in the constructor.
+
 #### `const info = await core.info([options])`
 
 Get information about this core, such as its total size in bytes.

package/index.js

@@ -14,8 +14,16 @@ const Core = require('./lib/core')
 const BlockEncryption = require('./lib/block-encryption')
 const Info = require('./lib/info')
 const Download = require('./lib/download')
+const Batch = require('./lib/batch')
 const { ReadStream, WriteStream, ByteStream } = require('./lib/streams')
-const { BAD_ARGUMENT, SESSION_CLOSED, SESSION_NOT_WRITABLE, SNAPSHOT_NOT_AVAILABLE } = require('./lib/errors')
+const {
+  BAD_ARGUMENT,
+  BATCH_ALREADY_EXISTS,
+  BATCH_UNFLUSHED,
+  SESSION_CLOSED,
+  SESSION_NOT_WRITABLE,
+  SNAPSHOT_NOT_AVAILABLE
+} = require('./lib/errors')
 
 const promises = Symbol.for('hypercore.promises')
 const inspect = Symbol.for('nodejs.util.inspect.custom')
@@ -82,6 +90,7 @@ module.exports = class Hypercore extends EventEmitter {
 
     this._preappend = preappend.bind(this)
     this._snapshot = null
+    this._batch = opts._batch || null
     this._findingPeers = 0
   }
 
@@ -175,13 +184,14 @@ module.exports = class Hypercore extends EventEmitter {
     const toLock = opts.unlocked ? null : (opts.lock || 'oplog')
     const pool = opts.pool || (opts.poolSize ? RAF.createPool(opts.poolSize) : null)
     const rmdir = !!opts.rmdir
+    const writable = opts.writable !== false
 
     return createFile
 
     function createFile (name) {
       const lock = toLock === null ? false : isFile(name, toLock)
       const sparse = isFile(name, 'data') || isFile(name, 'bitfield') || isFile(name, 'tree')
-      return new RAF(name, { directory, lock, sparse, pool: lock ? null : pool, rmdir })
+      return new RAF(name, { directory, lock, sparse, pool: lock ? null : pool, rmdir, writable })
     }
 
     function isFile (name, n) {
@@ -214,7 +224,8 @@ module.exports = class Hypercore extends EventEmitter {
       timeout,
       writable,
       _opening: this.opening,
-      _sessions: this.sessions
+      _sessions: this.sessions,
+      _batch: this._batch
     })
 
     s._passCapabilities(this)
@@ -321,11 +332,13 @@ module.exports = class Hypercore extends EventEmitter {
   async _openCapabilities (keyPair, storage, opts) {
     if (opts.from) return this._openFromExisting(opts.from, opts)
 
-    this.storage = Hypercore.defaultStorage(opts.storage || storage)
+    const unlocked = !!opts.unlocked
+    this.storage = Hypercore.defaultStorage(opts.storage || storage, { unlocked, writable: !unlocked })
 
     this.core = await Core.open(this.storage, {
       force: opts.force,
       createIfMissing: opts.createIfMissing,
+      readonly: unlocked,
       overwrite: opts.overwrite,
       keyPair,
       crypto: this.crypto,
@@ -684,6 +697,13 @@ module.exports = class Hypercore extends EventEmitter {
     return true
   }
 
+  batch () {
+    if (this._batch !== null) throw BATCH_ALREADY_EXISTS()
+    const batch = new Batch(this)
+    for (const session of this.sessions) session._batch = batch
+    return batch
+  }
+
   async seek (bytes, opts) {
     if (this.opened === false) await this.opening
 
@@ -846,6 +866,7 @@ module.exports = class Hypercore extends EventEmitter {
   }
 
   async truncate (newLength = 0, fork = -1) {
+    if (this._batch && !this._batch.flushed) throw BATCH_UNFLUSHED()
     if (this.opened === false) await this.opening
     if (this.writable === false) throw SESSION_NOT_WRITABLE()
 
@@ -857,6 +878,7 @@ module.exports = class Hypercore extends EventEmitter {
   }
 
   async append (blocks) {
+    if (this._batch && !this._batch.flushed) throw BATCH_UNFLUSHED()
     if (this.opened === false) await this.opening
     if (this.writable === false) throw SESSION_NOT_WRITABLE()
 

package/lib/batch.js

@@ -0,0 +1,114 @@
+const { SESSION_NOT_WRITABLE, BATCH_ALREADY_FLUSHED } = require('./errors')
+
+module.exports = class Batch {
+  constructor (session) {
+    this.session = session
+    this.flushed = false
+
+    this._appends = []
+    this._byteLength = 0
+  }
+
+  get length () {
+    return this.session.length + this._appends.length
+  }
+
+  ready () {
+    return this.session.ready()
+  }
+
+  async info (opts) {
+    const session = this.session
+    const info = await session.info(opts)
+
+    if (info.contiguousLength === info.length) {
+      info.contiguousLength = info.length += this._appends.length
+    } else {
+      info.length += this._appends.length
+    }
+
+    info.byteLength += this._byteLength
+
+    return info
+  }
+
+  async get (index, opts) {
+    const session = this.session
+    if (session.opened === false) await session.opening
+
+    const length = this.session.length
+    if (index < length) return this.session.get(index, opts)
+
+    return this._appends[index - length] || null
+  }
+
+  async truncate (newLength) {
+    if (this.flushed) throw BATCH_ALREADY_FLUSHED()
+
+    const session = this.session
+    if (session.opened === false) await session.opening
+    if (session.writable === false) throw SESSION_NOT_WRITABLE()
+
+    const length = session.length
+    if (newLength < length) throw new Error('Cannot truncate committed blocks')
+
+    this._appends.length = newLength - length
+  }
+
+  async append (blocks) {
+    if (this.flushed) throw BATCH_ALREADY_FLUSHED()
+
+    const session = this.session
+    if (session.opened === false) await session.opening
+    if (session.writable === false) throw SESSION_NOT_WRITABLE()
+
+    blocks = Array.isArray(blocks) ? blocks : [blocks]
+
+    const buffers = session.encodeBatch !== null
+      ? session.encodeBatch(blocks)
+      : new Array(blocks.length)
+
+    if (session.encodeBatch === null) {
+      for (let i = 0; i < blocks.length; i++) {
+        const buffer = session._encode(session.valueEncoding, blocks[i])
+        buffers[i] = buffer
+        this._byteLength += buffer.byteLength
+      }
+    }
+
+    this._appends.push(...buffers)
+
+    const byteLength = session.byteLength + this._byteLength
+
+    return { length: this.length, byteLength }
+  }
+
+  async flush () {
+    if (this.flushed) throw BATCH_ALREADY_FLUSHED()
+    this.flushed = true
+
+    try {
+      if (this._appends.length) await this.session.append(this._appends)
+    } finally {
+      this._clearBatch()
+      this._clearAppends()
+    }
+  }
+
+  async close () {
+    if (this.flushed) throw BATCH_ALREADY_FLUSHED()
+    this.flushed = true
+
+    this._clearBatch()
+    this._clearAppends()
+  }
+
+  _clearAppends () {
+    this._appends = []
+    this._byteLength = 0
+  }
+
+  _clearBatch () {
+    for (const session of this.session.sessions) session._batch = null
+  }
+}

package/lib/core.js

@@ -72,7 +72,8 @@ module.exports = class Core {
 
     const oplog = new Oplog(oplogFile, {
       headerEncoding: m.oplog.header,
-      entryEncoding: m.oplog.entry
+      entryEncoding: m.oplog.entry,
+      headerOnly: opts.readonly
     })
 
     let { header, entries } = await oplog.open()

package/lib/errors.js

@@ -64,6 +64,18 @@ module.exports = class HypercoreError extends Error {
     return new HypercoreError(msg, 'SESSION_CLOSED', HypercoreError.SESSION_CLOSED)
   }
 
+  static BATCH_UNFLUSHED (msg = 'Batch not yet flushed') {
+    return new HypercoreError(msg, 'BATCH_UNFLUSHED', HypercoreError.BATCH_UNFLUSHED)
+  }
+
+  static BATCH_ALREADY_EXISTS (msg = 'Batch already exists') {
+    return new HypercoreError(msg, 'BATCH_ALREADY_EXISTS', HypercoreError.BATCH_ALREADY_EXISTS)
+  }
+
+  static BATCH_ALREADY_FLUSHED (msg = 'Batch has already been flushed') {
+    return new HypercoreError(msg, 'BATCH_ALREADY_FLUSHED', HypercoreError.BATCH_ALREADY_FLUSHED)
+  }
+
   static OPLOG_CORRUPT (msg = 'Oplog file appears corrupt or out of date') {
     return new HypercoreError(msg, 'OPLOG_CORRUPT', HypercoreError.OPLOG_CORRUPT)
   }

package/lib/oplog.js

@@ -4,10 +4,11 @@ const { crc32 } = require('crc-universal')
 const { OPLOG_CORRUPT } = require('./errors')
 
 module.exports = class Oplog {
-  constructor (storage, { pageSize = 4096, headerEncoding = cenc.raw, entryEncoding = cenc.raw } = {}) {
+  constructor (storage, { pageSize = 4096, headerEncoding = cenc.raw, entryEncoding = cenc.raw, headerOnly = false } = {}) {
     this.storage = storage
     this.headerEncoding = headerEncoding
     this.entryEncoding = entryEncoding
+    this.headerOnly = headerOnly
     this.flushed = false
     this.byteLength = 0
     this.length = 0
@@ -101,6 +102,8 @@ module.exports = class Oplog {
 
     result.header = header ? h2.message : h1.message
 
+    if (this.headerOnly) return result
+
     while (true) {
       const entry = this._decodeEntry(state, this.entryEncoding)
       if (!entry) break

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hypercore",
-  "version": "10.12.0",
+  "version": "10.14.0",
   "description": "Hypercore is a secure, distributed append-only log",
   "main": "index.js",
   "scripts": {