@nxtedition/rocksdb 7.0.46 → 7.0.49

package/chained-batch.js

@@ -10,7 +10,6 @@ const kBatchContext = Symbol('batchContext')
 const kDbContext = Symbol('dbContext')
 const kPromise = Symbol('promise')
 
-const NOOP = () => {}
 const EMPTY = {}
 
 class ChainedBatch extends AbstractChainedBatch {

package/common.js

@@ -0,0 +1,7 @@
+module.exports.AbortError = class AbortError extends Error {
+  constructor () {
+    super('The operation was aborted')
+    this.code = 'ABORT_ERR'
+    this.name = 'AbortError'
+  }
+}

package/index.js

@@ -1,13 +1,16 @@
 'use strict'
 
 const { fromCallback } = require('catering')
+const { AbortError } = require('./common')
 const { AbstractLevel } = require('abstract-level')
 const ModuleError = require('module-error')
 const fs = require('fs')
 const binding = require('./binding')
 const { ChainedBatch } = require('./chained-batch')
 const { Iterator } = require('./iterator')
+const { Readable } = require('readable-stream')
 const os = require('os')
+const AbortController = require('abort-controller')
 
 const kContext = Symbol('context')
 const kColumns = Symbol('columns')
@@ -108,7 +111,7 @@ class RocksLevel extends AbstractLevel {
     } catch (err) {
       process.nextTick(callback, err)
     }
-    
+
     return callback[kPromise]
   }
 
@@ -281,6 +284,11 @@ class RocksLevel extends AbstractLevel {
   }
 
   async * updates (options) {
+    // TODO (fix): Ensure open status etc...?
+    if (this.status !== 'open') {
+      throw new Error('Database is not open')
+    }
+
     if (this.status !== 'open') {
       throw new ModuleError('Database is not open', {
         code: 'LEVEL_DATABASE_NOT_OPEN'
@@ -292,12 +300,14 @@ class RocksLevel extends AbstractLevel {
       keys: options?.keys ?? true,
       values: options?.values ?? true,
       data: options?.data ?? true,
-      column: options?.column ?? null
+      live: options?.live ?? false,
+      column: options?.column ?? null,
+      signal: options?.signal ?? null
     }
 
     // HACK: We don't properly check for nully column in binding.
-    if (!options.column) {
-      delete options.column
+    if (options.column) {
+      throw new TypeError("'column' not supported")
     }
 
     if (typeof options.since !== 'number') {
@@ -320,6 +330,85 @@ class RocksLevel extends AbstractLevel {
       throw new TypeError("'column' must be nully or a object")
     }
 
+    if (typeof options.live !== 'boolean') {
+      throw new TypeError("'live' must be nully or a boolean")
+    }
+
+    const ac = new AbortController()
+    const onAbort = () => {
+      ac.abort()
+    }
+
+    options.signal?.addEventListener('abort', onAbort)
+
+    try {
+      let since = options.since
+
+      const db = this
+      while (true) {
+        const buffer = new Readable({
+          signal: ac.signal,
+          objectMode: true,
+          readableHighWaterMark: 1024,
+          construct (callback) {
+            this._next = (batch, sequence) => {
+              const rows = []
+              for (const { type, key, value } of batch) {
+                rows.push(type, key, value, null)
+              }
+              if (!this.push({ rows, sequence, count: batch.length })) {
+                this.push(null)
+                db.off('write', this._next)
+              }
+            }
+            db.on('write', this._next)
+            callback()
+          },
+          read () {},
+          destroy (err, callback) {
+            db.off('write', this._next)
+            callback(err)
+          }
+        })
+
+        if (ac.signal.aborted) {
+          throw new AbortError()
+        }
+
+        try {
+          if (since <= this.sequence) {
+            for await (const update of this._updates(options)) {
+              if (ac.signal.aborted) {
+                throw new AbortError()
+              }
+
+              yield update
+              since = update.sequence + update.count
+            }
+          }
+        } catch (err) {
+          if (err.code !== 'LEVEL_TRYAGAIN') {
+            throw err
+          }
+        }
+
+        if (!options.live) {
+          return
+        }
+
+        for await (const update of buffer) {
+          if (update.sequence >= since) {
+            yield update
+            since = update.sequence + update.count
+          }
+        }
+      }
+    } finally {
+      options.signal?.removeventListener('abort', onAbort)
+    }
+  }
+
+  async * _updates (options) {
     class Updates {
       constructor (db, options) {
         this.context = binding.updates_init(db[kContext], options)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/rocksdb",
-  "version": "7.0.46",
+  "version": "7.0.49",
   "description": "A low-level Node.js RocksDB binding",
   "license": "MIT",
   "main": "index.js",
@@ -11,11 +11,13 @@
     "rebuild": "npm run install --build-from-source"
   },
   "dependencies": {
+    "abort-controller": "^3.0.0",
     "abstract-level": "^1.0.2",
     "catering": "^2.1.1",
     "module-error": "^1.0.2",
     "napi-macros": "~2.0.0",
-    "node-gyp-build": "^4.3.0"
+    "node-gyp-build": "^4.3.0",
+    "readable-stream": "^4.1.0"
   },
   "devDependencies": {
     "@types/node": "^17.0.16",