hypercore 10.12.0 → 10.13.0

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
   }
 
@@ -214,7 +223,8 @@ module.exports = class Hypercore extends EventEmitter {
       timeout,
       writable,
       _opening: this.opening,
-      _sessions: this.sessions
+      _sessions: this.sessions,
+      _batch: this._batch
     })
 
     s._passCapabilities(this)
@@ -684,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
 
@@ -846,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()
 
@@ -857,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.12.0",
+  "version": "10.13.0",
   "description": "Hypercore is a secure, distributed append-only log",
   "main": "index.js",
   "scripts": {