jexidb 1.0.2 → 1.0.3

package/README.md

@@ -35,6 +35,8 @@ const db = new Database('path/to/database.jdb', { // file will be created if it
   }
 });
 ```
+You can [learn a bit more about these options at this link](https://github.com/EdenwareApps/jexidb/tree/main/test#readme).
+
 
 ### Initializing the Database
 

package/dist/Database.cjs

@@ -7,8 +7,7 @@ exports.Database = void 0;
 var _events = require("events");
 var _FileHandler = _interopRequireDefault(require("./FileHandler.mjs"));
 var _IndexManager = _interopRequireDefault(require("./IndexManager.mjs"));
-var _Simple = _interopRequireDefault(require("./serializers/Simple.mjs"));
-var _Advanced = _interopRequireDefault(require("./serializers/Advanced.mjs"));
+var _Serializer = _interopRequireDefault(require("./Serializer.mjs"));
 var _fs = _interopRequireDefault(require("fs"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
@@ -45,7 +44,7 @@ function AsyncGenerator(e) { var r, t; function resume(r, t) { try { var n = e[r
 AsyncGenerator.prototype["function" == typeof Symbol && Symbol.asyncIterator || "@@asyncIterator"] = function () { return this; }, AsyncGenerator.prototype.next = function (e) { return this._invoke("next", e); }, AsyncGenerator.prototype["throw"] = function (e) { return this._invoke("throw", e); }, AsyncGenerator.prototype["return"] = function (e) { return this._invoke("return", e); };
 function _OverloadYield(e, d) { this.v = e, this.k = d; }
 var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
-  function Database(filePath) {
+  function Database(file) {
     var _this2;
     var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     _classCallCheck(this, Database);
@@ -60,13 +59,10 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
       compressIndex: false,
       maxMemoryUsage: 64 * 1024 // 64KB
     }, opts);
+    _this2.offsets = [];
     _this2.shouldSave = false;
-    if (_this2.opts.v8 || _this2.opts.compress || _this2.opts.compressIndex) {
-      _this2.serializer = new _Advanced["default"](_this2.opts);
-    } else {
-      _this2.serializer = new _Simple["default"](_this2.opts);
-    }
-    _this2.fileHandler = new _FileHandler["default"](filePath);
+    _this2.serializer = new _Serializer["default"](_this2.opts);
+    _this2.fileHandler = new _FileHandler["default"](file);
     _this2.indexManager = new _IndexManager["default"](_this2.opts);
     _this2.indexOffset = 0;
     _this2.writeBuffer = [];
@@ -165,7 +161,7 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
             case 38:
               _context.prev = 38;
               _context.t0 = _context["catch"](9);
-              if (!this.offsets) {
+              if (Array.isArray(this.offsets)) {
                 this.offsets = [];
               }
               this.indexOffset = 0;
@@ -204,18 +200,30 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
               }
               throw new Error('Database is destroyed');
             case 2:
-              if (!this.saving) {
+              if (this.initialized) {
                 _context2.next = 4;
                 break;
               }
+              throw new Error('Database not initialized');
+            case 4:
+              if (!this.saving) {
+                _context2.next = 6;
+                break;
+              }
               return _context2.abrupt("return", new Promise(function (resolve) {
                 return _this4.once('save', resolve);
               }));
-            case 4:
+            case 6:
               this.saving = true;
-              _context2.next = 7;
+              _context2.next = 9;
               return this.flush();
-            case 7:
+            case 9:
+              if (this.shouldSave) {
+                _context2.next = 11;
+                break;
+              }
+              return _context2.abrupt("return");
+            case 11:
               this.emit('before-save');
               index = Object.assign({
                 data: {}
@@ -226,12 +234,14 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
                 }
               }
               offsets = this.offsets.slice(0);
-              _context2.next = 13;
+              _context2.next = 17;
               return this.serializer.serialize(index, {
-                compress: this.opts.compressIndex
+                compress: this.opts.compressIndex,
+                linebreak: true
               });
-            case 13:
+            case 17:
               indexString = _context2.sent;
+              // force linebreak here to allow 'init' to read last line as offsets correctly
               for (_field in this.indexManager.index.data) {
                 for (_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
@@ -239,22 +249,15 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
               }
               offsets.push(this.indexOffset);
               offsets.push(this.indexOffset + indexString.length);
-              _context2.next = 19;
+              // save offsets as JSON always to prevent linebreaks on last line, which breaks 'init()'
+              _context2.next = 23;
               return this.serializer.serialize(offsets, {
-                compress: this.opts.compressIndex,
+                json: true,
+                compress: false,
                 linebreak: false
               });
-            case 19:
-              offsetsString = _context2.sent;
-              if (!this.shouldTruncate) {
-                _context2.next = 24;
-                break;
-              }
-              _context2.next = 23;
-              return this.fileHandler.truncate(this.indexOffset);
             case 23:
-              this.shouldTruncate = false;
-            case 24:
+              offsetsString = _context2.sent;
               this.writeBuffer.push(indexString);
               this.writeBuffer.push(offsetsString);
               _context2.next = 28;
@@ -390,17 +393,24 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
               }
               throw new Error('Database is destroyed');
             case 2:
-              _context5.next = 4;
+              if (this.initialized) {
+                _context5.next = 5;
+                break;
+              }
+              _context5.next = 5;
+              return this.init();
+            case 5:
+              if (this.shouldTruncate) {
+                this.writeBuffer.push(this.indexOffset);
+                this.shouldTruncate = false;
+              }
+              _context5.next = 8;
               return this.serializer.serialize(data, {
                 compress: this.opts.compress
               });
-            case 4:
+            case 8:
               line = _context5.sent;
               // using Buffer for offsets accuracy
-              if (this.shouldTruncate) {
-                this.writeBuffer.push(this.indexOffset);
-                this.shouldTruncate = false;
-              }
               position = this.offsets.length;
               this.offsets.push(this.indexOffset);
               this.indexOffset += line.length;
@@ -408,14 +418,14 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
               this.emit('insert', data, position);
               this.writeBuffer.push(line);
               if (!(!this.flushing && this.currentWriteBufferSize() > this.opts.maxMemoryUsage)) {
-                _context5.next = 15;
+                _context5.next = 18;
                 break;
               }
-              _context5.next = 15;
+              _context5.next = 18;
               return this.flush();
-            case 15:
+            case 18:
               this.shouldSave = true;
-            case 16:
+            case 19:
             case "end":
               return _context5.stop();
           }
@@ -442,16 +452,18 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
     key: "flush",
     value: function flush() {
       var _this7 = this;
-      if (this.flushing) return this.flushing;
-      return new Promise(function (resolve, reject) {
+      if (this.flushing) {
+        return this.flushing;
+      }
+      return this.flushing = new Promise(function (resolve, reject) {
         if (_this7.destroyed) return reject(new Error('Database is destroyed'));
         if (!_this7.writeBuffer.length) return resolve();
         var err;
-        _this7.flushing = _this7._flush()["catch"](function (e) {
+        _this7._flush()["catch"](function (e) {
           return err = e;
         })["finally"](function () {
-          _this7.flushing = false;
           err ? reject(err) : resolve();
+          _this7.flushing = false;
         });
       });
     }
@@ -464,7 +476,7 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
           while (1) switch (_context6.prev = _context6.next) {
             case 0:
               _context6.next = 2;
-              return _fs["default"].promises.open(this.fileHandler.filePath, 'a');
+              return _fs["default"].promises.open(this.fileHandler.file, 'a');
             case 2:
               fd = _context6.sent;
               _context6.prev = 3;
@@ -488,7 +500,7 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
               return this.fileHandler.truncate(this.writeBuffer.shift());
             case 12:
               _context6.next = 14;
-              return _fs["default"].promises.open(this.fileHandler.filePath, 'a');
+              return _fs["default"].promises.open(this.fileHandler.file, 'a');
             case 14:
               fd = _context6.sent;
               return _context6.abrupt("continue", 4);
@@ -547,20 +559,27 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
               }
               throw new Error('Database is destroyed');
             case 2:
+              if (_this.initialized) {
+                _context8.next = 5;
+                break;
+              }
+              _context8.next = 5;
+              return _awaitAsyncGenerator(_this.init());
+            case 5:
               _context8.t0 = _this.shouldSave;
               if (!_context8.t0) {
-                _context8.next = 6;
+                _context8.next = 9;
                 break;
               }
-              _context8.next = 6;
+              _context8.next = 9;
               return _awaitAsyncGenerator(_this.save()["catch"](console.error));
-            case 6:
+            case 9:
               if (!(_this.indexOffset === 0)) {
-                _context8.next = 8;
+                _context8.next = 11;
                 break;
               }
               return _context8.abrupt("return");
-            case 8:
+            case 11:
               if (!Array.isArray(map)) {
                 if (map && _typeof(map) === 'object') {
                   map = _this.indexManager.query(map, options.matchAny);
@@ -581,15 +600,15 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
               }
               m = 0;
               _i = 0, _partitionedRanges = partitionedRanges;
-            case 14:
+            case 17:
               if (!(_i < _partitionedRanges.length)) {
-                _context8.next = 31;
+                _context8.next = 34;
                 break;
               }
               _ranges = _partitionedRanges[_i];
-              _context8.next = 18;
+              _context8.next = 21;
               return _awaitAsyncGenerator(_this.fileHandler.readRanges(_ranges));
-            case 18:
+            case 21:
               lines = _context8.sent;
               _loop = /*#__PURE__*/_regeneratorRuntime().mark(function _loop() {
                 var err, entry;
@@ -621,27 +640,27 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
                 }, _loop);
               });
               _context8.t1 = _regeneratorRuntime().keys(lines);
-            case 21:
+            case 24:
               if ((_context8.t2 = _context8.t1()).done) {
-                _context8.next = 28;
+                _context8.next = 31;
                 break;
               }
               _line = _context8.t2.value;
-              return _context8.delegateYield(_loop(), "t3", 24);
-            case 24:
+              return _context8.delegateYield(_loop(), "t3", 27);
+            case 27:
               if (!_context8.t3) {
-                _context8.next = 26;
+                _context8.next = 29;
                 break;
               }
-              return _context8.abrupt("continue", 21);
-            case 26:
-              _context8.next = 21;
+              return _context8.abrupt("continue", 24);
+            case 29:
+              _context8.next = 24;
               break;
-            case 28:
+            case 31:
               _i++;
-              _context8.next = 14;
+              _context8.next = 17;
               break;
-            case 31:
+            case 34:
             case "end":
               return _context8.stop();
           }
@@ -671,21 +690,28 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
               }
               throw new Error('Database is destroyed');
             case 3:
+              if (this.initialized) {
+                _context9.next = 6;
+                break;
+              }
+              _context9.next = 6;
+              return this.init();
+            case 6:
               _context9.t0 = this.shouldSave;
               if (!_context9.t0) {
-                _context9.next = 7;
+                _context9.next = 10;
                 break;
               }
-              _context9.next = 7;
+              _context9.next = 10;
               return this.save()["catch"](console.error);
-            case 7:
+            case 10:
               if (!Array.isArray(criteria)) {
-                _context9.next = 16;
+                _context9.next = 19;
                 break;
               }
-              _context9.next = 10;
+              _context9.next = 13;
               return this.readLines(criteria);
-            case 10:
+            case 13:
               results = _context9.sent;
               if (options.orderBy) {
                 _options$orderBy$spli = options.orderBy.split(' '), _options$orderBy$spli2 = _slicedToArray(_options$orderBy$spli, 2), field = _options$orderBy$spli2[0], _options$orderBy$spli3 = _options$orderBy$spli2[1], direction = _options$orderBy$spli3 === void 0 ? 'asc' : _options$orderBy$spli3;
@@ -699,22 +725,22 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
                 results = results.slice(0, options.limit);
               }
               return _context9.abrupt("return", results);
-            case 16:
-              _context9.next = 18;
+            case 19:
+              _context9.next = 21;
               return this.indexManager.query(criteria, options.matchAny);
-            case 18:
+            case 21:
               matchingLines = _context9.sent;
               if (!(!matchingLines || !matchingLines.size)) {
-                _context9.next = 21;
+                _context9.next = 24;
                 break;
               }
               return _context9.abrupt("return", []);
-            case 21:
-              _context9.next = 23;
+            case 24:
+              _context9.next = 26;
               return this.query(_toConsumableArray(matchingLines), options);
-            case 23:
+            case 26:
               return _context9.abrupt("return", _context9.sent);
-            case 24:
+            case 27:
             case "end":
               return _context9.stop();
           }
@@ -747,47 +773,58 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
           while (1) switch (_context11.prev = _context11.next) {
             case 0:
               options = _args11.length > 2 && _args11[2] !== undefined ? _args11[2] : {};
+              if (this.shouldTruncate) {
+                this.writeBuffer.push(this.indexOffset);
+                this.shouldTruncate = false;
+              }
               if (!this.destroyed) {
-                _context11.next = 3;
+                _context11.next = 4;
                 break;
               }
               throw new Error('Database is destroyed');
-            case 3:
-              _context11.t0 = this.shouldSave;
-              if (!_context11.t0) {
+            case 4:
+              if (this.initialized) {
                 _context11.next = 7;
                 break;
               }
               _context11.next = 7;
-              return this.save()["catch"](console.error);
+              return this.init();
             case 7:
-              _context11.next = 9;
+              _context11.t0 = this.shouldSave;
+              if (!_context11.t0) {
+                _context11.next = 11;
+                break;
+              }
+              _context11.next = 11;
+              return this.save()["catch"](console.error);
+            case 11:
+              _context11.next = 13;
               return this.indexManager.query(criteria, options.matchAny);
-            case 9:
+            case 13:
               matchingLines = _context11.sent;
               if (!(!matchingLines || !matchingLines.size)) {
-                _context11.next = 12;
+                _context11.next = 16;
                 break;
               }
               return _context11.abrupt("return", []);
-            case 12:
+            case 16:
               ranges = this.getRanges(_toConsumableArray(matchingLines));
               validMatchingLines = new Set(ranges.map(function (r) {
                 return r.index;
               }));
               if (validMatchingLines.size) {
-                _context11.next = 16;
+                _context11.next = 20;
                 break;
               }
               return _context11.abrupt("return", []);
-            case 16:
-              _context11.next = 18;
+            case 20:
+              _context11.next = 22;
               return this.readLines(_toConsumableArray(validMatchingLines), ranges);
-            case 18:
+            case 22:
               entries = _context11.sent;
               lines = [];
               _iterator = _createForOfIteratorHelper(entries);
-              _context11.prev = 21;
+              _context11.prev = 25;
               _loop2 = /*#__PURE__*/_regeneratorRuntime().mark(function _loop2() {
                 var entry, err, updated, ret;
                 return _regeneratorRuntime().wrap(function _loop2$(_context10) {
@@ -809,27 +846,27 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
                 }, _loop2);
               });
               _iterator.s();
-            case 24:
+            case 28:
               if ((_step = _iterator.n()).done) {
-                _context11.next = 28;
+                _context11.next = 32;
                 break;
               }
-              return _context11.delegateYield(_loop2(), "t1", 26);
-            case 26:
-              _context11.next = 24;
+              return _context11.delegateYield(_loop2(), "t1", 30);
+            case 30:
+              _context11.next = 28;
               break;
-            case 28:
-              _context11.next = 33;
+            case 32:
+              _context11.next = 37;
               break;
-            case 30:
-              _context11.prev = 30;
-              _context11.t2 = _context11["catch"](21);
+            case 34:
+              _context11.prev = 34;
+              _context11.t2 = _context11["catch"](25);
               _iterator.e(_context11.t2);
-            case 33:
-              _context11.prev = 33;
+            case 37:
+              _context11.prev = 37;
               _iterator.f();
-              return _context11.finish(33);
-            case 36:
+              return _context11.finish(37);
+            case 40:
               offsets = [];
               byteOffset = 0, k = 0;
               this.offsets.forEach(function (n, i) {
@@ -843,20 +880,20 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
               });
               this.offsets = offsets;
               this.indexOffset += byteOffset;
-              _context11.next = 43;
+              _context11.next = 47;
               return this.fileHandler.replaceLines(ranges, lines);
-            case 43:
+            case 47:
               _toConsumableArray(validMatchingLines).forEach(function (lineNumber, i) {
                 _this8.indexManager.dryRemove(lineNumber);
                 _this8.indexManager.add(entries[i], lineNumber);
               });
               this.shouldSave = true;
               return _context11.abrupt("return", entries);
-            case 46:
+            case 50:
             case "end":
               return _context11.stop();
           }
-        }, _callee9, this, [[21, 30, 33, 36]]);
+        }, _callee9, this, [[25, 34, 37, 40]]);
       }));
       function update(_x5, _x6) {
         return _update.apply(this, arguments);
@@ -879,37 +916,48 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
           while (1) switch (_context12.prev = _context12.next) {
             case 0:
               options = _args12.length > 1 && _args12[1] !== undefined ? _args12[1] : {};
+              if (this.shouldTruncate) {
+                this.writeBuffer.push(this.indexOffset);
+                this.shouldTruncate = false;
+              }
               if (!this.destroyed) {
-                _context12.next = 3;
+                _context12.next = 4;
                 break;
               }
               throw new Error('Database is destroyed');
-            case 3:
-              _context12.t0 = this.shouldSave;
-              if (!_context12.t0) {
+            case 4:
+              if (this.initialized) {
                 _context12.next = 7;
                 break;
               }
               _context12.next = 7;
-              return this.save()["catch"](console.error);
+              return this.init();
             case 7:
-              _context12.next = 9;
+              _context12.t0 = this.shouldSave;
+              if (!_context12.t0) {
+                _context12.next = 11;
+                break;
+              }
+              _context12.next = 11;
+              return this.save()["catch"](console.error);
+            case 11:
+              _context12.next = 13;
               return this.indexManager.query(criteria, options.matchAny);
-            case 9:
+            case 13:
               matchingLines = _context12.sent;
               if (!(!matchingLines || !matchingLines.size)) {
-                _context12.next = 12;
+                _context12.next = 16;
                 break;
               }
               return _context12.abrupt("return", 0);
-            case 12:
+            case 16:
               ranges = this.getRanges(_toConsumableArray(matchingLines));
               validMatchingLines = new Set(ranges.map(function (r) {
                 return r.index;
               }));
-              _context12.next = 16;
+              _context12.next = 20;
               return this.fileHandler.replaceLines(ranges, []);
-            case 16:
+            case 20:
               offsets = [];
               byteOffset = 0, k = 0;
               this.offsets.forEach(function (n, i) {
@@ -926,7 +974,7 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
               this.indexManager.remove(_toConsumableArray(validMatchingLines));
               this.shouldSave = true;
               return _context12.abrupt("return", ranges.length);
-            case 24:
+            case 28:
             case "end":
               return _context12.stop();
           }
@@ -972,7 +1020,8 @@ var Database = exports.Database = /*#__PURE__*/function (_EventEmitter) {
   }, {
     key: "length",
     get: function get() {
-      return this.offsets.length;
+      var _this$offsets;
+      return (this === null || this === void 0 || (_this$offsets = this.offsets) === null || _this$offsets === void 0 ? void 0 : _this$offsets.length) || 0;
     }
   }, {
     key: "index",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jexidb",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "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",
@@ -11,7 +11,7 @@
     }
   },
   "scripts": {
-    "test": "node test/test.mjs && exit 1",
+    "test": "node --expose-gc test/test.mjs && exit 1",
     "build": "npx babel src/Database.mjs --plugins @babel/plugin-transform-async-generator-functions --out-file-extension .cjs --out-dir dist"
   },
   "author": "EdenwareApps",

package/src/Database.mjs

@@ -1,12 +1,11 @@
 import { EventEmitter } from 'events'
 import FileHandler from './FileHandler.mjs'
 import IndexManager from './IndexManager.mjs'
-import Serializer from './serializers/Simple.mjs'
-import AdvancedSerializer from './serializers/Advanced.mjs'
+import Serializer from './Serializer.mjs'
 import fs from 'fs'
 
 export class Database extends EventEmitter {
-  constructor(filePath, opts={}) {
+  constructor(file, opts={}) {
     super()
     this.opts = Object.assign({
       v8: false,
@@ -16,13 +15,10 @@ export class Database extends EventEmitter {
       compressIndex: false,
       maxMemoryUsage: 64 * 1024 // 64KB
     }, opts)
+    this.offsets = []
     this.shouldSave = false
-    if(this.opts.v8 || this.opts.compress || this.opts.compressIndex) {
-      this.serializer = new AdvancedSerializer(this.opts)
-    } else {
-      this.serializer = new Serializer(this.opts)
-    }
-    this.fileHandler = new FileHandler(filePath)
+    this.serializer = new Serializer(this.opts)
+    this.fileHandler = new FileHandler(file)
     this.indexManager = new IndexManager(this.opts)
     this.indexOffset = 0
     this.writeBuffer = []
@@ -60,7 +56,7 @@ export class Database extends EventEmitter {
       const index = await this.serializer.deserialize(indexLine, {compress: this.opts.compressIndex})
       index && this.indexManager.load(index)
     } catch (e) {
-      if(!this.offsets) {
+      if(Array.isArray(this.offsets)) {
         this.offsets = []
       }
       this.indexOffset = 0
@@ -76,9 +72,11 @@ 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))
     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) {
@@ -87,7 +85,7 @@ export class Database extends EventEmitter {
       }
     }
     const offsets = this.offsets.slice(0)
-    const indexString = await this.serializer.serialize(index, {compress: this.opts.compressIndex})
+    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
@@ -95,11 +93,8 @@ export class Database extends EventEmitter {
     }
     offsets.push(this.indexOffset)
     offsets.push(this.indexOffset + indexString.length)
-    const offsetsString = await this.serializer.serialize(offsets, {compress: this.opts.compressIndex, linebreak: false})
-    if (this.shouldTruncate) {
-        await this.fileHandler.truncate(this.indexOffset)
-        this.shouldTruncate = false
-    }
+    // 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})
     this.writeBuffer.push(indexString)
     this.writeBuffer.push(offsetsString)
     await this.flush() // write the index and offsets
@@ -122,7 +117,7 @@ export class Database extends EventEmitter {
       }
       return
     }
-    let end = this.offsets[n + 1] || this.indexOffset || Number.MAX_SAFE_INTEGER
+    let end = (this.offsets[n + 1] || this.indexOffset || Number.MAX_SAFE_INTEGER)
     return [this.offsets[n], end]
   }
   
@@ -147,11 +142,12 @@ export class Database extends EventEmitter {
 
   async insert(data) {
     if(this.destroyed) throw new Error('Database is destroyed')
-    const line = await this.serializer.serialize(data, {compress: this.opts.compress}) // using Buffer for offsets accuracy
+    if(!this.initialized) await this.init()
     if (this.shouldTruncate) {
         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 position = this.offsets.length
     this.offsets.push(this.indexOffset)
     this.indexOffset += line.length
@@ -170,20 +166,22 @@ export class Database extends EventEmitter {
   }
 
   flush() {
-    if(this.flushing) return this.flushing
-    return new Promise((resolve, reject) => {
+    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()
       let err
-      this.flushing = this._flush().catch(e => err = e).finally(() => {
-        this.flushing = false
+      this._flush().catch(e => err = e).finally(() => {
         err ? reject(err) : resolve()
+        this.flushing = false
       })
     })
   }
 
   async _flush() {
-    let fd = await fs.promises.open(this.fileHandler.filePath, 'a')
+    let fd = await fs.promises.open(this.fileHandler.file, 'a')
     try {
       while(this.writeBuffer.length) {
         let data
@@ -191,7 +189,7 @@ export class Database extends EventEmitter {
         if(pos === 0) {
           await fd.close()
           await this.fileHandler.truncate(this.writeBuffer.shift())
-          fd = await fs.promises.open(this.fileHandler.filePath, 'a')
+          fd = await fs.promises.open(this.fileHandler.file, 'a')
           continue
         } else if(pos === -1) {
           data = Buffer.concat(this.writeBuffer)
@@ -212,6 +210,7 @@ export class Database extends EventEmitter {
 
   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)) {
@@ -250,6 +249,7 @@ export class Database extends EventEmitter {
 
   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)) {
       let results = await this.readLines(criteria)
@@ -275,7 +275,12 @@ export class Database extends EventEmitter {
   }
 
   async update(criteria, data, options={}) {
+    if (this.shouldTruncate) {
+        this.writeBuffer.push(this.indexOffset)
+        this.shouldTruncate = false
+    }
     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.matchAny)
     if (!matchingLines || !matchingLines.size) {
@@ -317,7 +322,12 @@ export class Database extends EventEmitter {
   }
 
   async delete(criteria, options={}) {
+    if (this.shouldTruncate) {
+        this.writeBuffer.push(this.indexOffset)
+        this.shouldTruncate = false
+    }
     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.matchAny)
     if (!matchingLines || !matchingLines.size) {
@@ -355,7 +365,7 @@ export class Database extends EventEmitter {
   }
 
   get length() {
-    return this.offsets.length
+    return this?.offsets?.length || 0
   }
 
   get index() {

package/src/FileHandler.mjs

@@ -2,21 +2,21 @@ import fs from 'fs'
 import pLimit from 'p-limit'
 
 export default class FileHandler {
-  constructor(filePath) {
-    this.filePath = filePath
+  constructor(file) {
+    this.file = file
   }
 
   async truncate(offset) {
     try {
-      await fs.promises.access(this.filePath, fs.constants.F_OK)
-      await fs.promises.truncate(this.filePath, offset)
+      await fs.promises.access(this.file, fs.constants.F_OK)
+      await fs.promises.truncate(this.file, offset)
     } catch (err) {
-      await fs.promises.writeFile(this.filePath, '')
+      await fs.promises.writeFile(this.file, '')
     }
   }
 
   async readRange(start, end) {
-    let fd = await fs.promises.open(this.filePath, 'r')
+    let fd = await fs.promises.open(this.file, 'r')
     const length = end - start
     let buffer = Buffer.alloc(length)
     const { bytesRead } = await fd.read(buffer, 0, length, start).catch(console.error)    
@@ -27,7 +27,7 @@ export default class FileHandler {
 
   async readRanges(ranges, mapper) {
     const lines = {}, limit = pLimit(4)
-    const fd = await fs.promises.open(this.filePath, 'r')
+    const fd = await fs.promises.open(this.file, 'r')
     try {
       const tasks = ranges.map(r => {
         return async () => {
@@ -50,9 +50,9 @@ export default class FileHandler {
 
   async replaceLines(ranges, lines) {
     let closed
-    const tmpFile = this.filePath + '.tmp'
+    const tmpFile = this.file + '.tmp'
     const writer = await fs.promises.open(tmpFile, 'w+')
-    const reader = await fs.promises.open(this.filePath, 'r')
+    const reader = await fs.promises.open(this.file, 'r')
     try {
       let i = 0, start = 0
       for (const r of ranges) {
@@ -74,7 +74,7 @@ export default class FileHandler {
       await reader.close()
       await writer.close()
       closed = true
-      await fs.promises.copyFile(tmpFile, this.filePath)
+      await fs.promises.copyFile(tmpFile, this.file)
     } catch (e) {
       console.error('Error replacing lines:', e)
     } finally {
@@ -90,11 +90,11 @@ export default class FileHandler {
   }
 
   writeDataSync(data) {
-    fs.writeFileSync(this.filePath, data, { flag: 'a' })
+    fs.writeFileSync(this.file, data, { flag: 'a' })
   }
 
   async readLastLine() {
-    const reader = await fs.promises.open(this.filePath, 'r')
+    const reader = await fs.promises.open(this.file, 'r')
     try {
       const { size } = await reader.stat()
       if (size < 1) throw 'empty file'

package/src/{serializers/Advanced.mjs → Serializer.mjs}

@@ -6,9 +6,6 @@ export default class Serializer extends EventEmitter {
   constructor(opts = {}) {
     super()
     this.opts = Object.assign({}, opts)
-    this.linebreak = Buffer.from([0x0A])
-    this.delimiter = Buffer.from([0xFF, 0xFF, 0xFF, 0xFF])
-    this.defaultBuffer = Buffer.alloc(4096)
     this.brotliOptions = {
       params: {
         [zlib.constants.BROTLI_PARAM_QUALITY]: 4
@@ -19,56 +16,54 @@ export default class Serializer extends EventEmitter {
   async serialize(data, opts={}) {
     let line
     let header = 0x00 // 1 byte de header
-    const useV8 = this.opts.v8 || opts.v8 === true
-    const compress = this.opts.compress || opts.compress === true
+    const useV8 = (this.opts.v8 && opts.json !== true) || opts.v8 === true
+    const compress = (this.opts.compress && opts.compress !== false) || opts.compress === true
+    const addLinebreak = opts.linebreak !== false || (!useV8 && !compress && opts.linebreak !== false)
     if (useV8) {
       header |= 0x02 // set V8
       line = v8.serialize(data)
     } else {
-      if(compress) {
-        line = Buffer.from(JSON.stringify(data), 'utf-8')
-      } else {
-        return Buffer.from(JSON.stringify(data) + (opts.linebreak !== false ? '\n' : ''), 'utf-8')
-      }
+      let json = JSON.stringify(data)
+      line = Buffer.from(json, 'utf-8')
     }
     if (compress) {
       let err
-      const buffer = await this.compress(line).catch(e => err = e)
-      if(!err) {
+      const compressionType = useV8 ? 'deflate' : 'brotli'
+      const buffer = await this.compress(line, compressionType).catch(e => err = e)
+      if(!err && buffer.length && buffer.length < line.length) {
         header |= 0x01
         line = buffer
       }
     }
-    const totalLength = 1 + line.length + (opts.linebreak !== false ? 1 : 0)
+    const totalLength = 1 + line.length + (addLinebreak ? 1 : 0)
     const result = Buffer.alloc(totalLength)
     result[0] = header
-    line.copy(result, 1)
-    if (opts.linebreak !== false) {
-      result[totalLength - 1] = 0x0A
+    line.copy(result, 1, 0, line.length)
+    if(addLinebreak) {
+      result[result.length - 1] = 0x0A
     }
     return result
   }  
 
-  async deserialize(data, opts={}) {
-    let line
+  async deserialize(data) {
+    let line, isCompressed, isV8
     const header = data.readUInt8(0)
     const valid = header === 0x00 || header === 0x01 || header === 0x02 || header === 0x03
-    let isCompressed, isV8, decompresssed
     if(valid) {
       isCompressed = (header & 0x01) === 0x01
       isV8 = (header & 0x02) === 0x02
       line = data.subarray(1) // remove byte header
     } else {
       isCompressed = isV8 = false
-      line = data
+      try {
+        return JSON.parse(data.toString('utf-8').trim())
+      } catch (e) {
+        throw new Error('Failed to deserialize legacy JSON data')
+      }
     }
     if (isCompressed) {
-      let err
-      const buffer = await this.decompress(line).catch(e => err = e)
-      if(!err) {
-        decompresssed = true
-        line = buffer
-      }
+      const compressionType = isV8 ? 'deflate' : 'brotli'
+      line = await this.decompress(line, compressionType).catch(e => err = e)
     }
     if (isV8) {
       try {
@@ -80,41 +75,43 @@ export default class Serializer extends EventEmitter {
       try {
         return JSON.parse(line.toString('utf-8').trim())
       } catch (e) {
-        console.error('Failed to deserialize', header, line.toString('utf-8').trim())
         throw new Error('Failed to deserialize JSON data')
       }
     }
   }
 
-  compress(data) {
+  compress(data, type) {
     return new Promise((resolve, reject) => {
-      zlib.brotliCompress(data, this.brotliOptions, (err, buffer) => {
+      const callback = (err, buffer) => {
         if (err) {
           reject(err)
         } else {
           resolve(buffer)
         }
-      })
+      }
+      if(type === 'brotli') {
+        zlib.brotliCompress(data, this.brotliOptions, callback)
+      } else {
+        zlib.deflate(data, callback)
+      }
     })
   }
 
-  decompress(data) {
+  decompress(data, type) {
     return new Promise((resolve, reject) => {
-      zlib.brotliDecompress(data, (err, buffer) => {
+      const callback = (err, buffer) => {
         if (err) {
           reject(err)
         } else {
           resolve(buffer)
         }
-      })
+      }
+      if(type === 'brotli') {
+        zlib.brotliDecompress(data, callback)
+      } else {
+        zlib.inflate(data, callback)
+      }
     })
   }
-
-  async safeDeserialize(json) {
-    try {
-      return await this.deserialize(json)
-    } catch (e) {
-      return null
-    }
-  }
+  
 }

package/test/README.md

@@ -0,0 +1,13 @@
+## Test Results
+The following are the results of the automated tests conducted on my PC for different serialization formats and compression methods.
+
+| Format                         | Size (bytes) | Time elapsed (ms) |
+|-------------------------------|--------------|--------------------|
+| JSON                          | 1117         | 21                 |
+| V8 Serialization              | 1124         | 12 🏆       |
+| JSON with Brotli Compression   | 1038	🏆 | 20              |
+| V8 with Brotli Compression     | 1052         | 15                |
+
+When using V8 for serialization, be aware that serialized data may not deserialize correctly across different versions of V8 (which powers Chromium, Node.js, and Electron), leading to potential data loss or corruption. This issue is specific to V8 serialization; however, when using JSON, the data remains universal and compatible across environments.
+
+To avoid this issue, always use your V8 database with the same version of Node.js.

package/test/test.mjs

@@ -50,13 +50,8 @@ const runTests = async (id, name, format, opts) => {
     // Path to the test file
     const testFilePath = path.join(__dirname, 'test-' + name + '.jdb');
     
-    // Function to clear the test file before each run
-    const clearTestFile = () => {
-        fs.writeFileSync(testFilePath, '', { encoding: null });
-    }
-
     console.log('Battle #' + id + ' (' + format + ') is starting...\n');
-    clearTestFile(); // Clear the file before starting the tests
+    fs.writeFileSync(testFilePath, '', { encoding: null }); // Clear the file before starting the tests
     const start = Date.now()
     const db = new Database(testFilePath, opts); // Instantiate the database
 
@@ -97,7 +92,6 @@ const runTests = async (id, name, format, opts) => {
 
     // 5. Test data deletion
     await db.delete({ name: character.name + ' Updated' });
-    
     results = await db.query({ id: { '<=': 2 } });
     const pass5 = results.length === 1;
     const pass6 = results[0].name === 'Sub-Zero';
@@ -108,43 +102,65 @@ const runTests = async (id, name, format, opts) => {
     // End the battle and log the result
     if(pass1 && pass2 && pass4 && pass5 && pass6) {
         let err, elapsed = Date.now() - start;
-        elapsed = elapsed < 1000 ? elapsed + 'ms' : (elapsed / 1000).toFixed(3) + 's';
         const { size } = await fs.promises.stat(testFilePath);
-        benchmarks[format] = { elapsed, size };
+        if(!benchmarks[format]) {
+            benchmarks[format] = { elapsed, size }
+        } else {
+            benchmarks[format].elapsed = (elapsed + benchmarks[format].elapsed)
+            benchmarks[format].size = (size + benchmarks[format].size)
+        }
         console.log(`\nBattle #${id} ended: All tests with format "${format}" ran successfully! Fatality avoided this time.\n\n`);
+        global.gc()
     } else {
         benchmarks[format] = { elapsed: 'Error', size: 'Error' };
+        global.gc();
         throw `\nBattle #${id} ended: Some tests failed with format "${format}"! Time to train harder.\n\n`;
     }
 }
 
 async function runAllTests() {
-    let err
-    await runTests(1, 'json', 'JSON', {
-        indexes: {id: 'number', name: 'string'},
-        v8: false,
-        compress: false,
-        compressIndex: false
-    }).catch(e => err = e)
-    await runTests(2, 'v8', 'V8 serialization', {
-        indexes: {id: 'number', name: 'string'},
-        v8: true,
-        compress: false,
-        compressIndex: false
-    }).catch(e => err = e)
-    await runTests(3, 'json-compressed', 'JSON with Brotli compression', {
-        indexes: {id: 'number', name: 'string'},
-        v8: false,
-        compress: false,
-        compressIndex: true
-    }).catch(e => err = e)
-    await runTests(3, 'v8-compressed', 'V8 with Brotli compression', {
-        indexes: {id: 'number', name: 'string'},
-        v8: true,
-        compress: false,
-        compressIndex: true
-    }).catch(e => err = e)
+    const depth = 100
+    let err, i = 1
+    let tests = [
+        ['json', 'JSON', { indexes: { id: 'number', name: 'string' }, v8: false, compress: false, compressIndex: false }],
+        ['v8', 'V8 serialization', { indexes: { id: 'number', name: 'string' }, v8: true, compress: false, compressIndex: false }],
+        ['json-compressed', 'JSON with Brotli compression', { indexes: { id: 'number', name: 'string' }, v8: false, compress: false, compressIndex: true }],
+        ['v8-compressed', 'V8 with Deflate compression', { indexes: { id: 'number', name: 'string' }, v8: true, compress: false, compressIndex: true }]
+    ]
+    tests = Array(depth).fill(tests).flat()
+    tests = tests.map(value => ({ value, sort: Math.random() })).sort((a, b) => a.sort - b.sort).map(({ value }) => value)
+    for(const test of tests) {
+        await runTests(i++, test[0], test[1], test[2]).catch(e => {
+            benchmarks[test[1]] = { elapsed: 'Error', size: 'Error' };
+            console.error(e)
+            err = e
+        })
+    }
+    const winners = {}
+    for (const [format, result] of Object.entries(benchmarks)) {
+        if (result.elapsed !== 'Error' && result.size !== 'Error') {
+            if (typeof(winners.elapsed) === 'undefined' || result.elapsed < winners.elapsed) {
+                winners.elapsed = result.elapsed
+                winners.format = format
+            }
+            if (typeof(winners.size) === 'undefined' || result.size < winners.size) {
+                winners.size = result.size
+                winners.format = format
+            }
+        }
+    }
+    for(const format in benchmarks) {
+        for(const prop of ['elapsed', 'size']) {
+            if(benchmarks[format][prop] === winners[prop]) {
+                benchmarks[format][prop] += ' \uD83C\uDFC6'
+            }
+        }
+    }
+    console.log('Benchmarks results after '+ tests.length +' battles:')
     console.table(benchmarks)
+    // setInterval(() => {}, 1000)
+    // global.Database = Database
+    // global.__dirname = __dirname
     process.exit(err ? 1 : 0)
 }
 

package/src/serializers/Simple.mjs

@@ -1,21 +0,0 @@
-export default class Serializer {
-
-  constructor(opts={}) {
-    this.opts = Object.assign({}, opts)
-  }
-
-  async serialize(data, opts={}) {
-    return Buffer.from(JSON.stringify(data) + (opts.linebreak !== false ? '\n' : ''), 'utf-8')
-  }  
-
-  async deserialize(data, opts={}) {
-    const line = data.toString('utf-8')
-    try {
-      return JSON.parse(line)
-    } catch (e) {
-      console.error('Failed to deserialize', line)
-      throw new Error('Failed to deserialize JSON data')
-    }
-  }
-  
-}