jexidb 1.0.6 → 1.0.8

package/.gitattributes

@@ -1,2 +1,2 @@
-# Auto detect text files and perform LF normalization
-* text=auto
+# Auto detect text files and perform LF normalization
+* text=auto

package/dist/Database.cjs

@@ -8,6 +8,7 @@ var _events = require("events");
 var _FileHandler = _interopRequireDefault(require("./FileHandler.mjs"));
 var _IndexManager = _interopRequireDefault(require("./IndexManager.mjs"));
 var _Serializer = _interopRequireDefault(require("./Serializer.mjs"));
+var _asyncMutex = require("async-mutex");
 var _fs = _interopRequireDefault(require("fs"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
 function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
@@ -67,6 +68,7 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
     _this2.indexManager = new _IndexManager["default"](_this2.opts);
     _this2.indexOffset = 0;
     _this2.writeBuffer = [];
+    _this2.mutex = new _asyncMutex.Mutex();
     return _this2;
   }
   _inherits(Database, _EventEmitter);
@@ -407,7 +409,8 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
               }
               _context5.next = 8;
               return this.serializer.serialize(data, {
-                compress: this.opts.compress
+                compress: this.opts.compress,
+                v8: this.opts.v8
               });
             case 8:
               line = _context5.sent;
@@ -415,16 +418,16 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
               position = this.offsets.length;
               this.offsets.push(this.indexOffset);
               this.indexOffset += line.length;
-              this.indexManager.add(data, position);
               this.emit('insert', data, position);
               this.writeBuffer.push(line);
               if (!(!this.flushing && this.currentWriteBufferSize() > this.opts.maxMemoryUsage)) {
-                _context5.next = 18;
+                _context5.next = 17;
                 break;
               }
-              _context5.next = 18;
+              _context5.next = 17;
               return this.flush();
-            case 18:
+            case 17:
+              this.indexManager.add(data, position);
               this.shouldSave = true;
             case 19:
             case "end":
@@ -472,18 +475,22 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
     key: "_flush",
     value: function () {
       var _flush2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
-        var fd, data, pos;
+        var release, fd, data, pos, err;
         return _regeneratorRuntime().wrap(function _callee6$(_context6) {
           while (1) switch (_context6.prev = _context6.next) {
             case 0:
               _context6.next = 2;
-              return _fs["default"].promises.open(this.fileHandler.file, 'a');
+              return this.mutex.acquire();
             case 2:
+              release = _context6.sent;
+              _context6.next = 5;
+              return _fs["default"].promises.open(this.fileHandler.file, 'a');
+            case 5:
               fd = _context6.sent;
-              _context6.prev = 3;
-            case 4:
+              _context6.prev = 6;
+            case 7:
               if (!this.writeBuffer.length) {
-                _context6.next = 23;
+                _context6.next = 26;
                 break;
               }
               data = void 0;
@@ -491,21 +498,21 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
                 return typeof b === 'number';
               });
               if (!(pos === 0)) {
-                _context6.next = 18;
+                _context6.next = 21;
                 break;
               }
-              _context6.next = 10;
+              _context6.next = 13;
               return fd.close();
-            case 10:
-              _context6.next = 12;
+            case 13:
+              _context6.next = 15;
               return this.fileHandler.truncate(this.writeBuffer.shift());
-            case 12:
-              _context6.next = 14;
+            case 15:
+              _context6.next = 17;
               return _fs["default"].promises.open(this.fileHandler.file, 'a');
-            case 14:
+            case 17:
               fd = _context6.sent;
-              return _context6.abrupt("continue", 4);
-            case 18:
+              return _context6.abrupt("continue", 7);
+            case 21:
               if (pos === -1) {
                 data = Buffer.concat(this.writeBuffer);
                 this.writeBuffer.length = 0;
@@ -513,31 +520,35 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
                 data = Buffer.concat(this.writeBuffer.slice(0, pos));
                 this.writeBuffer.splice(0, pos);
               }
-            case 19:
-              _context6.next = 21;
+            case 22:
+              _context6.next = 24;
               return fd.write(data);
-            case 21:
-              _context6.next = 4;
+            case 24:
+              _context6.next = 7;
               break;
-            case 23:
+            case 26:
               this.shouldSave = true;
-              _context6.next = 29;
+              _context6.next = 32;
               break;
-            case 26:
-              _context6.prev = 26;
-              _context6.t0 = _context6["catch"](3);
-              console.error('Error flushing:', _context6.t0);
             case 29:
               _context6.prev = 29;
-              _context6.next = 32;
-              return fd.close();
+              _context6.t0 = _context6["catch"](6);
+              console.error('Error flushing:', _context6.t0);
             case 32:
-              return _context6.finish(29);
-            case 33:
+              _context6.prev = 32;
+              _context6.next = 35;
+              return fd.close()["catch"](function (e) {
+                return err = e;
+              });
+            case 35:
+              release();
+              err && console.error('Error closing file:', err);
+              return _context6.finish(32);
+            case 38:
             case "end":
               return _context6.stop();
           }
-        }, _callee6, this, [[3, 26, 29, 33]]);
+        }, _callee6, this, [[6, 29, 32, 38]]);
       }));
       function _flush() {
         return _flush2.apply(this, arguments);
@@ -550,7 +561,7 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
       var _this = this;
       var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       return _wrapAsyncGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee7() {
-        var ranges, readSize, groupedRanges, fd, _iterator2, _step2, groupedRange, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, row, entry;
+        var ranges, groupedRanges, fd, _iterator2, _step2, groupedRange, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, row, entry;
         return _regeneratorRuntime().wrap(function _callee7$(_context7) {
           while (1) switch (_context7.prev = _context7.next) {
             case 0:
@@ -591,21 +602,21 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
                 }
               }
               ranges = _this.getRanges(map);
-              readSize = 512 * 1024; // 512KB
-              _context7.next = 16;
+              _context7.next = 15;
               return _awaitAsyncGenerator(_this.fileHandler.groupedRanges(ranges));
-            case 16:
+            case 15:
               groupedRanges = _context7.sent;
-              _context7.next = 19;
+              _context7.next = 18;
               return _awaitAsyncGenerator(_fs["default"].promises.open(_this.fileHandler.file, 'r'));
-            case 19:
+            case 18:
               fd = _context7.sent;
+              _context7.prev = 19;
               _iterator2 = _createForOfIteratorHelper(groupedRanges);
               _context7.prev = 21;
               _iterator2.s();
             case 23:
               if ((_step2 = _iterator2.n()).done) {
-                _context7.next = 64;
+                _context7.next = 66;
                 break;
               }
               groupedRange = _step2.value;
@@ -618,85 +629,95 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
               return _awaitAsyncGenerator(_iterator.next());
             case 31:
               if (!(_iteratorAbruptCompletion = !(_step = _context7.sent).done)) {
-                _context7.next = 46;
+                _context7.next = 48;
                 break;
               }
               row = _step.value;
               _context7.next = 35;
               return _awaitAsyncGenerator(_this.serializer.deserialize(row.line, {
-                compress: _this.opts.compress
+                compress: _this.opts.compress,
+                v8: _this.opts.v8
               }));
             case 35:
               entry = _context7.sent;
+              if (!(entry === null)) {
+                _context7.next = 38;
+                break;
+              }
+              return _context7.abrupt("continue", 45);
+            case 38:
               if (!options.includeOffsets) {
-                _context7.next = 41;
+                _context7.next = 43;
                 break;
               }
-              _context7.next = 39;
+              _context7.next = 41;
               return {
                 entry: entry,
                 start: row.start
               };
-            case 39:
-              _context7.next = 43;
-              break;
             case 41:
-              _context7.next = 43;
-              return entry;
+              _context7.next = 45;
+              break;
             case 43:
+              _context7.next = 45;
+              return entry;
+            case 45:
               _iteratorAbruptCompletion = false;
               _context7.next = 29;
               break;
-            case 46:
-              _context7.next = 52;
-              break;
             case 48:
-              _context7.prev = 48;
+              _context7.next = 54;
+              break;
+            case 50:
+              _context7.prev = 50;
               _context7.t1 = _context7["catch"](27);
               _didIteratorError = true;
               _iteratorError = _context7.t1;
-            case 52:
-              _context7.prev = 52;
-              _context7.prev = 53;
+            case 54:
+              _context7.prev = 54;
+              _context7.prev = 55;
               if (!(_iteratorAbruptCompletion && _iterator["return"] != null)) {
-                _context7.next = 57;
+                _context7.next = 59;
                 break;
               }
-              _context7.next = 57;
+              _context7.next = 59;
               return _awaitAsyncGenerator(_iterator["return"]());
-            case 57:
-              _context7.prev = 57;
+            case 59:
+              _context7.prev = 59;
               if (!_didIteratorError) {
-                _context7.next = 60;
+                _context7.next = 62;
                 break;
               }
               throw _iteratorError;
-            case 60:
-              return _context7.finish(57);
-            case 61:
-              return _context7.finish(52);
             case 62:
-              _context7.next = 23;
-              break;
+              return _context7.finish(59);
+            case 63:
+              return _context7.finish(54);
             case 64:
-              _context7.next = 69;
+              _context7.next = 23;
               break;
             case 66:
-              _context7.prev = 66;
+              _context7.next = 71;
+              break;
+            case 68:
+              _context7.prev = 68;
               _context7.t2 = _context7["catch"](21);
               _iterator2.e(_context7.t2);
-            case 69:
-              _context7.prev = 69;
+            case 71:
+              _context7.prev = 71;
               _iterator2.f();
-              return _context7.finish(69);
-            case 72:
-              _context7.next = 74;
-              return _awaitAsyncGenerator(fd.close());
+              return _context7.finish(71);
             case 74:
+              _context7.prev = 74;
+              _context7.next = 77;
+              return _awaitAsyncGenerator(fd.close());
+            case 77:
+              return _context7.finish(74);
+            case 78:
             case "end":
               return _context7.stop();
           }
-        }, _callee7, null, [[21, 66, 69, 72], [27, 48, 52, 62], [53,, 57, 61]]);
+        }, _callee7, null, [[19,, 74, 78], [21, 68, 71, 74], [27, 50, 54, 64], [55,, 59, 63]]);
       }))();
     }
   }, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jexidb",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "JexiDB is a pure JS NPM library for managing data on disk using JSONL efficiently, without the need for a server.",
   "main": "./dist/Database.cjs",
   "module": "./src/Database.mjs",
@@ -23,6 +23,7 @@
     "@babel/preset-env": "^7.25.4"
   },
   "dependencies": {
+    "async-mutex": "^0.5.0",
     "p-limit": "^6.1.0"
   },
   "directories": {

package/src/Database.mjs

@@ -2,14 +2,15 @@ import { EventEmitter } from 'events'
 import FileHandler from './FileHandler.mjs'
 import IndexManager from './IndexManager.mjs'
 import Serializer from './Serializer.mjs'
+import { Mutex } from 'async-mutex'
 import fs from 'fs'
 
 export class Database extends EventEmitter {
-  constructor(file, opts={}) {
+  constructor(file, opts = {}) {
     super()
     this.opts = Object.assign({
       v8: false,
-      index: {data: {}},
+      index: { data: {} },
       indexes: {},
       compress: false,
       compressIndex: false,
@@ -22,29 +23,30 @@ export class Database extends EventEmitter {
     this.indexManager = new IndexManager(this.opts)
     this.indexOffset = 0
     this.writeBuffer = []
+    this.mutex = new Mutex()
   }
 
   use(plugin) {
-    if(this.destroyed) throw new Error('Database is destroyed')
+    if (this.destroyed) throw new Error('Database is destroyed')
     plugin(this)
   }
 
   async init() {
-    if(this.destroyed) throw new Error('Database is destroyed')
-    if(this.initialized) return
-    if(this.initlializing) return await new Promise(resolve => this.once('init', resolve))
+    if (this.destroyed) throw new Error('Database is destroyed')
+    if (this.initialized) return
+    if (this.initlializing) return await new Promise(resolve => this.once('init', resolve))
     this.initializing = true
     try {
-      if(this.opts.clear) {
+      if (this.opts.clear) {
         await this.fileHandler.truncate(0).catch(console.error)
         throw new Error('Cleared, empty file')
       }
       const lastLine = await this.fileHandler.readLastLine()
-      if(!lastLine || !lastLine.length) {
+      if (!lastLine || !lastLine.length) {
         throw new Error('File does not exists or is a empty file')
       }
-      const offsets = await this.serializer.deserialize(lastLine, {compress: this.opts.compressIndex})
-      if(!Array.isArray(offsets)) {
+      const offsets = await this.serializer.deserialize(lastLine, { compress: this.opts.compressIndex })
+      if (!Array.isArray(offsets)) {
         throw new Error('File to parse offsets, expected an array')
       }
       this.indexOffset = offsets[offsets.length - 2]
@@ -53,14 +55,14 @@ export class Database extends EventEmitter {
       this.offsets = this.offsets.slice(0, -2)
       this.shouldTruncate = true
       let indexLine = await this.fileHandler.readRange(...ptr)
-      const index = await this.serializer.deserialize(indexLine, {compress: this.opts.compressIndex})
+      const index = await this.serializer.deserialize(indexLine, { compress: this.opts.compressIndex })
       index && this.indexManager.load(index)
     } catch (e) {
-      if(Array.isArray(this.offsets)) {
+      if (Array.isArray(this.offsets)) {
         this.offsets = []
       }
       this.indexOffset = 0
-      if(!String(e).includes('empty file')) {
+      if (!String(e).includes('empty file')) {
         console.error('Error loading database:', e)
       }
     } finally {
@@ -71,30 +73,30 @@ export class Database extends EventEmitter {
   }
 
   async save() {
-    if(this.destroyed) throw new Error('Database is destroyed')
-    if(!this.initialized) throw new Error('Database not initialized')
-    if(this.saving) return new Promise(resolve => this.once('save', resolve))
+    if (this.destroyed) throw new Error('Database is destroyed')
+    if (!this.initialized) throw new Error('Database not initialized')
+    if (this.saving) return new Promise(resolve => this.once('save', resolve))
     this.saving = true
     await this.flush()
     if (!this.shouldSave) return
     this.emit('before-save')
-    const index = Object.assign({data: {}}, this.indexManager.index)
-    for(const field in this.indexManager.index.data) {
-      for(const term in this.indexManager.index.data[field]) {
+    const index = Object.assign({ data: {} }, this.indexManager.index)
+    for (const field in this.indexManager.index.data) {
+      for (const term in this.indexManager.index.data[field]) {
         index.data[field][term] = [...this.indexManager.index.data[field][term]] // set to array 
       }
     }
     const offsets = this.offsets.slice(0)
-    const indexString = await this.serializer.serialize(index, {compress: this.opts.compressIndex, linebreak: true}) // force linebreak here to allow 'init' to read last line as offsets correctly
-    for(const field in this.indexManager.index.data) {
-      for(const term in this.indexManager.index.data[field]) {
+    const indexString = await this.serializer.serialize(index, { compress: this.opts.compressIndex, linebreak: true }) // force linebreak here to allow 'init' to read last line as offsets correctly
+    for (const field in this.indexManager.index.data) {
+      for (const term in this.indexManager.index.data[field]) {
         this.indexManager.index.data[field][term] = new Set(index.data[field][term]) // set back to set because of serialization
       }
     }
     offsets.push(this.indexOffset)
     offsets.push(this.indexOffset + indexString.length)
     // save offsets as JSON always to prevent linebreaks on last line, which breaks 'init()'
-    const offsetsString = await this.serializer.serialize(offsets, {json: true, compress: false, linebreak: false})
+    const offsetsString = await this.serializer.serialize(offsets, { json: true, compress: false, linebreak: false })
     this.writeBuffer.push(indexString)
     this.writeBuffer.push(offsetsString)
     await this.flush() // write the index and offsets
@@ -112,7 +114,7 @@ export class Database extends EventEmitter {
 
   locate(n) {
     if (this.offsets[n] === undefined) {
-      if(this.offsets[n - 1]) {
+      if (this.offsets[n - 1]) {
         return [this.indexOffset, Number.MAX_SAFE_INTEGER]
       }
       return
@@ -120,58 +122,58 @@ export class Database extends EventEmitter {
     let end = (this.offsets[n + 1] || this.indexOffset || Number.MAX_SAFE_INTEGER)
     return [this.offsets[n], end]
   }
-  
+
   getRanges(map) {
     return (map || Array.from(this.offsets.keys())).map(n => {
-        const ret = this.locate(n)
-        if(ret !== undefined) return {start: ret[0], end: ret[1], index: n}
+      const ret = this.locate(n)
+      if (ret !== undefined) return { start: ret[0], end: ret[1], index: n }
     }).filter(n => n !== undefined)
   }
 
   async readLines(map, ranges) {
-    if(!ranges) ranges = this.getRanges(map)
+    if (!ranges) ranges = this.getRanges(map)
     const results = await this.fileHandler.readRanges(ranges, this.serializer.deserialize.bind(this.serializer))
     let i = 0
-    for(const start in results) {
-      if(!results[start] || results[start]._ !== undefined) continue
-      while(this.offsets[i] != start && i < map.length) i++ // weak comparison as 'start' is a string
+    for (const start in results) {
+      if (!results[start] || results[start]._ !== undefined) continue
+      while (this.offsets[i] != start && i < map.length) i++ // weak comparison as 'start' is a string
       results[start]._ = map[i++]
     }
     return Object.values(results).filter(r => r !== undefined)
   }
 
   async insert(data) {
-    if(this.destroyed) throw new Error('Database is destroyed')
-    if(!this.initialized) await this.init()
+    if (this.destroyed) throw new Error('Database is destroyed')
+    if (!this.initialized) await this.init()
     if (this.shouldTruncate) {
-        this.writeBuffer.push(this.indexOffset)
-        this.shouldTruncate = false
+      this.writeBuffer.push(this.indexOffset)
+      this.shouldTruncate = false
     }
-    const line = await this.serializer.serialize(data, {compress: this.opts.compress}) // using Buffer for offsets accuracy
+    const line = await this.serializer.serialize(data, { compress: this.opts.compress, v8: this.opts.v8 }) // using Buffer for offsets accuracy
     const position = this.offsets.length
     this.offsets.push(this.indexOffset)
     this.indexOffset += line.length
-    this.indexManager.add(data, position)
     this.emit('insert', data, position)
     this.writeBuffer.push(line)
-    if(!this.flushing && this.currentWriteBufferSize() > this.opts.maxMemoryUsage) {
+    if (!this.flushing && this.currentWriteBufferSize() > this.opts.maxMemoryUsage) {
       await this.flush()
     }
+    this.indexManager.add(data, position)
     this.shouldSave = true
   }
 
-  currentWriteBufferSize(){
+  currentWriteBufferSize() {
     const lengths = this.writeBuffer.filter(b => Buffer.isBuffer(b)).map(b => b.length)
     return lengths.reduce((a, b) => a + b, 0)
   }
 
   flush() {
-    if(this.flushing) {
+    if (this.flushing) {
       return this.flushing
     }
     return this.flushing = new Promise((resolve, reject) => {
-      if(this.destroyed) return reject(new Error('Database is destroyed'))
-      if(!this.writeBuffer.length) return resolve()
+      if (this.destroyed) return reject(new Error('Database is destroyed'))
+      if (!this.writeBuffer.length) return resolve()
       let err
       this._flush().catch(e => err = e).finally(() => {
         err ? reject(err) : resolve()
@@ -181,17 +183,18 @@ export class Database extends EventEmitter {
   }
 
   async _flush() {
+    const release = await this.mutex.acquire()
     let fd = await fs.promises.open(this.fileHandler.file, 'a')
     try {
-      while(this.writeBuffer.length) {
+      while (this.writeBuffer.length) {
         let data
         const pos = this.writeBuffer.findIndex(b => typeof b === 'number')
-        if(pos === 0) {
+        if (pos === 0) {
           await fd.close()
           await this.fileHandler.truncate(this.writeBuffer.shift())
           fd = await fs.promises.open(this.fileHandler.file, 'a')
           continue
-        } else if(pos === -1) {
+        } else if (pos === -1) {
           data = Buffer.concat(this.writeBuffer)
           this.writeBuffer.length = 0
         } else {
@@ -201,66 +204,72 @@ export class Database extends EventEmitter {
         await fd.write(data)
       }
       this.shouldSave = true
-    } catch(err) {
+    } catch (err) {
       console.error('Error flushing:', err)
     } finally {
-      await fd.close()
+      let err
+      await fd.close().catch(e => err = e)
+      release()
+      err && console.error('Error closing file:', err)
     }
   }
 
-  async *walk(map, options={}) {
-    if(this.destroyed) throw new Error('Database is destroyed')
-    if(!this.initialized) await this.init()
+  async *walk(map, options = {}) {
+    if (this.destroyed) throw new Error('Database is destroyed')
+    if (!this.initialized) await this.init()
     this.shouldSave && await this.save().catch(console.error)
-    if(this.indexOffset === 0) return
-    if(!Array.isArray(map)) {
+    if (this.indexOffset === 0) return
+    if (!Array.isArray(map)) {
       if (map instanceof Set) {
         map = [...map]
-      } else if(map && typeof map === 'object') {
+      } else if (map && typeof map === 'object') {
         map = [...this.indexManager.query(map, options)]
       } else {
         map = [...Array(this.offsets.length).keys()]
       }
     }
     const ranges = this.getRanges(map)
-    const readSize = 512 * 1024 // 512KB
     const groupedRanges = await this.fileHandler.groupedRanges(ranges)
     const fd = await fs.promises.open(this.fileHandler.file, 'r')
-    for(const groupedRange of groupedRanges) {
-      for await (const row of this.fileHandler.readGroupedRange(groupedRange, fd)) {
-        const entry = await this.serializer.deserialize(row.line, {compress: this.opts.compress})
-        if(options.includeOffsets) {
-          yield {entry, start: row.start}
-        } else {
-          yield entry
+    try {
+      for (const groupedRange of groupedRanges) {
+        for await (const row of this.fileHandler.readGroupedRange(groupedRange, fd)) {
+          const entry = await this.serializer.deserialize(row.line, { compress: this.opts.compress, v8: this.opts.v8 })
+          if (entry === null) continue
+          if (options.includeOffsets) {
+            yield { entry, start: row.start }
+          } else {
+            yield entry
+          }
         }
       }
+    } finally {
+      await fd.close()
     }
-    await fd.close() 
   }
 
-  async query(criteria, options={}) {
-    if(this.destroyed) throw new Error('Database is destroyed')
-    if(!this.initialized) await this.init()
+  async query(criteria, options = {}) {
+    if (this.destroyed) throw new Error('Database is destroyed')
+    if (!this.initialized) await this.init()
     this.shouldSave && await this.save().catch(console.error)
-    if(Array.isArray(criteria)) {
+    if (Array.isArray(criteria)) {
       let results = await this.readLines(criteria)
       if (options.orderBy) {
-          const [field, direction = 'asc'] = options.orderBy.split(' ')
-          results.sort((a, b) => {
-              if (a[field] > b[field]) return direction === 'asc' ? 1 : -1
-              if (a[field] < b[field]) return direction === 'asc' ? -1 : 1
-              return 0;
-          })
+        const [field, direction = 'asc'] = options.orderBy.split(' ')
+        results.sort((a, b) => {
+          if (a[field] > b[field]) return direction === 'asc' ? 1 : -1
+          if (a[field] < b[field]) return direction === 'asc' ? -1 : 1
+          return 0;
+        })
       }
       if (options.limit) {
-          results = results.slice(0, options.limit);
+        results = results.slice(0, options.limit);
       }
       return results
     } else {
       const matchingLines = await this.indexManager.query(criteria, options)
       if (!matchingLines || !matchingLines.size) {
-          return []
+        return []
       }
       return await this.query([...matchingLines], options)
     }
@@ -313,17 +322,17 @@ export class Database extends EventEmitter {
     return entries
   }
 
-  async delete(criteria, options={}) {
+  async delete(criteria, options = {}) {
     if (this.shouldTruncate) {
-        this.writeBuffer.push(this.indexOffset)
-        this.shouldTruncate = false
+      this.writeBuffer.push(this.indexOffset)
+      this.shouldTruncate = false
     }
-    if(this.destroyed) throw new Error('Database is destroyed')
-    if(!this.initialized) await this.init()
+    if (this.destroyed) throw new Error('Database is destroyed')
+    if (!this.initialized) await this.init()
     this.shouldSave && await this.save().catch(console.error)
     const matchingLines = await this.indexManager.query(criteria, options)
     if (!matchingLines || !matchingLines.size) {
-        return 0
+      return 0
     }
     const ranges = this.getRanges([...matchingLines])
     const validMatchingLines = new Set(ranges.map(r => r.index))

package/src/FileHandler.mjs

@@ -24,17 +24,19 @@ export default class FileHandler {
     if(buffer.length > bytesRead) return buffer.subarray(0, bytesRead)
     return buffer
   }
-
+  
   async readRanges(ranges, mapper) {
     const lines = {}, limit = pLimit(4)
     const fd = await fs.promises.open(this.file, 'r')
     const groupedRanges = await this.groupedRanges(ranges)
     try {
-      for(const groupedRange of groupedRanges) {
-        for await (const row of this.readGroupedRange(groupedRange, fd)) {
-          lines[row.start] = mapper ? (await mapper(row.line, groupedRange)) : row.line
-        }
-      }
+      await Promise.allSettled(groupedRanges.map(async (groupedRange) => {
+        await limit(async () => {
+          for await (const row of this.readGroupedRange(groupedRange, fd)) {
+            lines[row.start] = mapper ? (await mapper(row.line, groupedRange)) : row.line
+          }
+        })
+      }))
     } catch (e) {
       console.error('Error reading ranges:', e)
     } finally {
@@ -43,7 +45,7 @@ export default class FileHandler {
     return lines
   }
 
-  async groupedRanges(ranges) {
+  async groupedRanges(ranges) { // expects ordered ranges from Database.getRanges()
     const readSize = 512 * 1024 // 512KB  
     const groupedRanges = []
     let currentGroup = []
@@ -79,62 +81,78 @@ export default class FileHandler {
     let i = 0, buffer = Buffer.alloc(options.end - options.start)
     const results = {}, { bytesRead } = await fd.read(buffer, 0, options.end - options.start, options.start)
     if(buffer.length > bytesRead) buffer = buffer.subarray(0, bytesRead)
-    for(const range of groupedRange) {
-      const line = buffer.subarray(range.start, range.end)
-      yield {line, start: range.start}
+
+    for (const range of groupedRange) {
+      const startOffset = range.start - options.start;
+      let endOffset = range.end - options.start;
+      if (endOffset > buffer.length) {
+        endOffset = buffer.length;
+      }
+      if (startOffset >= buffer.length) {
+        continue;
+      }
+      const line = buffer.subarray(startOffset, endOffset);
+      if (line.length === 0) continue;
+      yield { line, start: range.start };
     }
 
+
     return results
   }
 
-  async *walk(ranges, options={}) {
+  async *walk(ranges) {
     const fd = await fs.promises.open(this.file, 'r')
-    const groupedRanges = await this.groupedRanges(ranges)
-    for(const groupedRange of groupedRanges) {
-      for await (const row of this.readGroupedRange(groupedRange, fd)) {
-        yield row
+    try {
+      const groupedRanges = await this.groupedRanges(ranges)
+      for(const groupedRange of groupedRanges) {
+        for await (const row of this.readGroupedRange(groupedRange, fd)) {
+          yield row
+        }
       }
+    } finally {
+      await fd.close()
     }
-    await fd.close()
   }
 
   async replaceLines(ranges, lines) {
-    let closed
-    const tmpFile = this.file + '.tmp'
-    const writer = await fs.promises.open(tmpFile, 'w+')
-    const reader = await fs.promises.open(this.file, 'r')
+    const tmpFile = this.file + '.tmp';
+    const writer = await fs.promises.open(tmpFile, 'w+');
+    const reader = await fs.promises.open(this.file, 'r');
     try {
-      let i = 0, start = 0
-      for (const r of ranges) {
-        const length = r.start - start
-        const buffer = Buffer.alloc(length)
-        await reader.read(buffer, 0, length, start)
-        start = r.end
-        buffer.length && await writer.write(buffer)
-        if (lines[i]) {
-          await writer.write(lines[i])
+      let position = 0;
+      let lineIndex = 0;
+
+      for (const range of ranges) {
+        if (position < range.start) {
+          const buffer = await this.readRange(position, range.start);
+          await writer.write(buffer);
         }
-        i++
+        if (lineIndex < lines.length && lines[lineIndex]) {
+          await writer.write(lines[lineIndex]);
+        }
+        position = range.end;
+        lineIndex++;
+      }
+
+      const { size } = await reader.stat();
+      if (position < size) {
+        const buffer = await this.readRange(position, size);
+        await writer.write(buffer);
       }
-      const size = (await reader.stat()).size
-      const length = size - start
-      const buffer = Buffer.alloc(length)
-      await reader.read(buffer, 0, length, start)
-      await writer.write(buffer)
-      await reader.close()
-      await writer.close()
-      closed = true
-      await fs.promises.copyFile(tmpFile, this.file)
+
+      await reader.close();
+      await writer.close();
+      await fs.promises.rename(tmpFile, this.file);
     } catch (e) {
-      console.error('Error replacing lines:', e)
+      console.error('Erro ao substituir linhas:', e);
+      throw e;
     } finally {
-      if(!closed) {
-        await reader.close()
-        await writer.close()
-      }
-      await fs.promises.unlink(tmpFile).catch(() => {})
+      await reader.close().catch(() => { });
+      await writer.close().catch(() => { });
+      await fs.promises.unlink(tmpFile).catch(() => { });
     }
   }
+
   async writeData(data, immediate, fd) {
     await fd.write(data)
   }
@@ -150,18 +168,19 @@ export default class FileHandler {
       if (size < 1) throw 'empty file'
       this.size = size
       const bufferSize = 16384
-      let buffer, lastReadSize, readPosition = Math.max(size - bufferSize, 0)
+      let buffer, isFirstRead = true, lastReadSize, readPosition = Math.max(size - bufferSize, 0)
       while (readPosition >= 0) {
         const readSize = Math.min(bufferSize, size - readPosition)
         if (readSize !== lastReadSize) {
           lastReadSize = readSize
           buffer = Buffer.alloc(readSize)
         }
-        const { bytesRead } = await reader.read(buffer, 0, readSize, readPosition)
+        const { bytesRead } = await reader.read(buffer, 0, isFirstRead ? (readSize - 1) : readSize, readPosition)
+        if (isFirstRead) isFirstRead = false
         if (bytesRead === 0) break
-        const newlineIndex = buffer.lastIndexOf(10, size - 4) // 0x0A is the ASCII code for '\n'
+        const newlineIndex = buffer.lastIndexOf(10)
+        const start = readPosition + newlineIndex + 1
         if (newlineIndex !== -1) {
-          const start = readPosition + newlineIndex + 1
           const lastLine = Buffer.alloc(size - start)
           await reader.read(lastLine, 0, size - start, start)
           if (!lastLine || !lastLine.length) {

package/src/Serializer.mjs

@@ -46,6 +46,9 @@ export default class Serializer extends EventEmitter {
   }  
 
   async deserialize(data) {
+    if(data.length === 0) {
+      return null
+    }
     let line, isCompressed, isV8
     const header = data.readUInt8(0)
     const valid = header === 0x00 || header === 0x01 || header === 0x02 || header === 0x03
@@ -58,7 +61,7 @@ export default class Serializer extends EventEmitter {
       try {
         return JSON.parse(data.toString('utf-8').trim())
       } catch (e) {
-        throw new Error('Failed to deserialize legacy JSON data')
+        throw new Error('Failed to deserialize JSON data')
       }
     }
     if (isCompressed) {