apiro-db 1.0.7 → 1.0.8

package/lib/store.js

@@ -1,7 +1,7 @@
 const crypto = require("crypto");
 const { readFile, writeFile } = require("./file");
 const { encrypt, decrypt } = require("./crypto");
-const { generateMasterKey, encryptMasterKey, decryptMasterKey } = require("./masterKey");
+const { encryptMasterKey, decryptMasterKey } = require("./masterKey");
 const {
   getByPath,
   setByPath,
@@ -11,118 +11,136 @@ const {
 class SecureStore {
   constructor(options = {}) {
     this.file = options.file || "./secure.db";
+
     this.data = {};
     this.masterKey = null;
+
+    this._dirty = false;
+    this._writeTimer = null;
+    this._writeInProgress = false;
+
     this.ready = this._init();
   }
 
+  /* -----------------------------
+     INIT
+  ------------------------------ */
+
   async _init() {
     const existing = await readFile(this.file);
 
     if (!existing) {
       this.masterKey = crypto.randomBytes(32);
-      const encryptedKey = encryptMasterKey(this.masterKey);
-
-      const payload = encrypt(JSON.stringify({}), this.masterKey);
-
-      await writeFile(this.file, JSON.stringify({
-        _meta: { key: encryptedKey },
-        payload
-      }));
-
+      await this._flush(true);
       return;
     }
 
     const parsed = JSON.parse(existing);
     this.masterKey = decryptMasterKey(parsed._meta.key);
-    const decrypted = decrypt(parsed.payload, this.masterKey);
-    this.data = JSON.parse(decrypted);
+    this.data = JSON.parse(decrypt(parsed.payload, this.masterKey));
   }
 
-  async _save() {
-    const payload = encrypt(JSON.stringify(this.data), this.masterKey);
+  /* -----------------------------
+     WRITE-BEHIND ENGINE
+  ------------------------------ */
 
-    await writeFile(this.file, JSON.stringify({
-      _meta: { key: encryptMasterKey(this.masterKey) },
-      payload
-    }));
-  }
+  _scheduleFlush() {
+    this._dirty = true;
 
-  async get(key) {
-    await this.ready;
-    return getByPath(this.data, key);
-  }
+    if (this._writeTimer) return;
 
-  async set(key, value) {
-    await this.ready;
-    setByPath(this.data, key, value);
-    await this._save();
-    return value;
+    this._writeTimer = setTimeout(() => {
+      this._writeTimer = null;
+      this._flush();
+    }, 50);
   }
 
-  async delete(key) {
-    await this.ready;
-    const existed = deleteByPath(this.data, key);
-    await this._save();
-    return existed;
-  }
+  async _flush(force = false) {
+    if (this._writeInProgress) return;
+    if (!this._dirty && !force) return;
 
-  async add(key, amount) {
-    await this.ready;
+    this._writeInProgress = true;
+    this._dirty = false;
 
-    let current = getByPath(this.data, key);
-    if (typeof current !== "number") current = 0;
+    const payload = encrypt(
+      JSON.stringify(this.data),
+      this.masterKey
+    );
 
-    const next = current + amount;
-    setByPath(this.data, key, next);
+    await writeFile(
+      this.file,
+      JSON.stringify({
+        _meta: { key: encryptMasterKey(this.masterKey) },
+        payload
+      })
+    );
 
-    await this._save();
-    return next;
+    this._writeInProgress = false;
   }
 
-  async subtract(key, amount) {
+  /* -----------------------------
+     PUBLIC API (PATH-FIRST)
+  ------------------------------ */
+
+  async get(path) {
     await this.ready;
+    return getByPath(this.data, path);
+  }
 
-    let current = getByPath(this.data, key);
-    if (typeof current !== "number") current = 0;
+  async has(path) {
+    await this.ready;
+    return getByPath(this.data, path) !== undefined;
+  }
 
-    const next = current - amount;
-    setByPath(this.data, key, next);
+  async set(path, value) {
+    await this.ready;
+    setByPath(this.data, path, value);
+    this._scheduleFlush();
+    return value;
+  }
 
-    await this._save();
-    return next;
+  async delete(path) {
+    await this.ready;
+    const existed = deleteByPath(this.data, path);
+    if (existed) this._scheduleFlush();
+    return existed;
   }
 
-  async push(key, value) {
+  async add(path, amount) {
     await this.ready;
 
-    let arr = getByPath(this.data, key);
-    if (!Array.isArray(arr)) arr = [];
+    const current = getByPath(this.data, path);
+    const next = (typeof current === "number" ? current : 0) + amount;
 
-    arr.push(value);
-    setByPath(this.data, key, arr);
+    setByPath(this.data, path, next);
+    this._scheduleFlush();
+    return next;
+  }
 
-    await this._save();
-    return arr;
+  async subtract(path, amount) {
+    return this.add(path, -amount);
   }
 
-  async has(path, value) {
+  async push(path, value) {
     await this.ready;
 
     const current = getByPath(this.data, path);
+    const next = Array.isArray(current) ? current : [];
 
-    if (current === undefined) return false;
+    next.push(value);
+    setByPath(this.data, path, next);
 
-    if (value === undefined) return true;
+    this._scheduleFlush();
+    return next;
+  }
 
-    // If current is an array, check includes
-    if (Array.isArray(current)) {
-      return current.includes(value);
-    }
+  /* -----------------------------
+     SAFETY
+  ------------------------------ */
 
-    return current === value;
+  async close() {
+    await this._flush(true);
   }
-
 }
 
 module.exports = { SecureStore };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apiro-db",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "A lightweight, zero-dependency, encrypted data store for Node.js.",
   "main": "index.js",
   "scripts": {
@@ -8,7 +8,14 @@
   },
   "keywords": ["database", "storage", "encryption", "secure"],
   "author": "krispowers",
-  "license": "ISC",
+  "license": "MIT",
+  "contributors": [
+    {
+      "name": "Kris Powers",
+      "githubUsername": "krispowers",
+      "url": "https://github.com/KrisPowers"
+    }
+  ],
   "files": [
     "Readme.md",
     "index.js",