hypercore 10.11.0 → 10.13.0

package/README.md

@@ -72,7 +72,8 @@ Note that `tree`, `data`, and `bitfield` are normally heavily sparse files.
   encodeBatch: batch => { ... }, // optionally apply an encoding to complete batches
   keyPair: kp, // optionally pass the public key and secret key as a key pair
   encryptionKey: k, // optionally pass an encryption key to enable block encryption
-  onwait: () => {} // hook that is called if gets are waiting for download
+  onwait: () => {}, // hook that is called if gets are waiting for download
+  writable: true // disable appends and truncates
 }
 ```
 

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')
@@ -74,6 +82,7 @@ module.exports = class Hypercore extends EventEmitter {
     this.onwait = opts.onwait || null
     this.wait = opts.wait !== false
     this.timeout = opts.timeout || 0
+    this._readonly = opts.writable === false
 
     this.closing = null
     this.opening = this._openSession(key, storage, opts)
@@ -81,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
   }
 
@@ -201,6 +211,7 @@ module.exports = class Hypercore extends EventEmitter {
 
     const sparse = opts.sparse === false ? false : this.sparse
     const wait = opts.wait === false ? false : this.wait
+    const writable = opts.writable === false ? false : !this._readonly
     const onwait = opts.onwait === undefined ? this.onwait : opts.onwait
     const timeout = opts.timeout === undefined ? this.timeout : opts.timeout
     const Clz = opts.class || Hypercore
@@ -210,8 +221,10 @@ module.exports = class Hypercore extends EventEmitter {
       wait,
       onwait,
       timeout,
+      writable,
       _opening: this.opening,
-      _sessions: this.sessions
+      _sessions: this.sessions,
+      _batch: this._batch
     })
 
     s._passCapabilities(this)
@@ -237,7 +250,7 @@ module.exports = class Hypercore extends EventEmitter {
     this.core = o.core
     this.replicator = o.replicator
     this.encryption = o.encryption
-    this.writable = !!(this.auth && this.auth.sign)
+    this.writable = !this._readonly && !!(this.auth && this.auth.sign)
     this.autoClose = o.autoClose
 
     if (this.snapshotted && this.core && !this._snapshot) this._updateSnapshot()
@@ -295,7 +308,7 @@ module.exports = class Hypercore extends EventEmitter {
     }
 
     if (!this.auth) this.auth = this.core.defaultAuth
-    this.writable = !!this.auth.sign
+    this.writable = !this._readonly && !!this.auth.sign
 
     if (opts.valueEncoding) {
       this.valueEncoding = c.from(opts.valueEncoding)
@@ -681,6 +694,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
 
@@ -843,6 +863,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()
 
@@ -854,6 +875,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/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/package.json

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