json-database-st 2.0.2 → 3.1.4

package/JSONDatabase.legacy.js

@@ -0,0 +1,567 @@
+const fs = require("fs").promises;
+const fsSync = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const _ = require("lodash");
+const EventEmitter = require("events");
+const lockfile = require("proper-lockfile");
+
+// --- Custom Errors (Required for Tests) ---
+class DBError extends Error {
+  constructor(msg) {
+    super(msg);
+    this.name = this.constructor.name;
+  }
+}
+class TransactionError extends DBError {}
+class ValidationError extends DBError {
+  constructor(msg, issues) {
+    super(msg);
+    this.issues = issues;
+  }
+}
+
+/**
+ * JSONDatabase
+ * Restored full compatibility with Jest tests while keeping performance upgrades.
+ */
+class JSONDatabase extends EventEmitter {
+  constructor(filename, options = {}) {
+    super();
+
+    // 1. Security Checks
+    const resolvedPath = path.resolve(filename);
+    if (!resolvedPath.startsWith(process.cwd())) {
+      throw new Error(
+        "Security Violation: Database path must be inside the project directory."
+      );
+    }
+    this.filename = resolvedPath.endsWith(".json")
+      ? resolvedPath
+      : `${resolvedPath}.json`;
+
+    // 2. Configuration
+    this.config = {
+      encryptionKey: options.encryptionKey
+        ? Buffer.from(options.encryptionKey, "hex")
+        : null,
+      prettyPrint: options.prettyPrint !== false,
+      saveDelay: options.saveDelay || 60, // Debounce ms
+      indices: options.indices || [],
+      schema: options.schema || null,
+    };
+
+    if (this.config.encryptionKey && this.config.encryptionKey.length !== 32) {
+      throw new Error("Encryption key must be exactly 32 bytes.");
+    }
+
+    // 3. Internal State
+    this.data = {};
+    this._indices = new Map();
+    this._loaded = false;
+
+    // 4. Write Queue System (The "Bus")
+    this._writeQueue = [];
+    this._writeScheduled = false;
+    this._writeLockPromise = Promise.resolve();
+
+    // 5. Middleware
+    this._middleware = {
+      before: { set: [], delete: [], push: [], pull: [] },
+      after: { set: [], delete: [], push: [], pull: [] },
+    };
+
+    // 6. Initialize
+    this._initPromise = this._initialize();
+  }
+
+  // ==========================================
+  //           INTERNAL CORE
+  // ==========================================
+
+  async _initialize() {
+    try {
+      // Crash Recovery
+      if (fsSync.existsSync(this.filename + ".tmp")) {
+        try {
+          await fs.rename(this.filename + ".tmp", this.filename);
+        } catch (e) {}
+      }
+
+      // Ensure file exists
+      try {
+        await fs.access(this.filename);
+      } catch (e) {
+        // Do not create file here. Wait for first write.
+      }
+
+      // Read
+      const content = await fs.readFile(this.filename, "utf8");
+      this.data = content.trim()
+        ? this.config.encryptionKey
+          ? this._decrypt(content)
+          : JSON.parse(content)
+        : {};
+    } catch (e) {
+      this.data = {}; // Fallback
+    }
+    this._rebuildIndices();
+    this._loaded = true;
+    this.emit("ready");
+  }
+
+  async _ensureInitialized() {
+    if (!this._loaded) await this._initPromise;
+  }
+
+  /**
+   * The Shared Write Engine.
+   * Batches 10,000 calls into 1 disk write.
+   */
+  async _save() {
+    // Update indices instantly in memory
+    // this._rebuildIndices(); // REMOVED: Incremental updates are now used
+    this.emit("change", this.data);
+
+    return new Promise((resolve, reject) => {
+      this._writeQueue.push({ resolve, reject });
+
+      if (this._writeScheduled) return;
+
+      this._writeScheduled = true;
+      setTimeout(async () => {
+        // Wait for any previous physical write to finish
+        await this._writeLockPromise;
+
+        // Start physical write
+        this._writeLockPromise = (async () => {
+          // Take a snapshot of everyone waiting and clear the queue
+          const subscribers = [...this._writeQueue];
+          this._writeQueue = [];
+          this._writeScheduled = false;
+
+          let release;
+          try {
+            // Ensure file exists before locking
+            try {
+              await fs.access(this.filename);
+            } catch (e) {
+              await fs.mkdir(path.dirname(this.filename), { recursive: true });
+              try {
+                await fs.writeFile(this.filename, "", { flag: "wx" });
+              } catch (err) {
+                if (err.code !== "EEXIST") throw err;
+              }
+            }
+
+            release = await lockfile.lock(this.filename, { retries: 3 });
+
+            const content = this.config.encryptionKey
+              ? this._encrypt(this.data)
+              : JSON.stringify(
+                  this.data,
+                  null,
+                  this.config.prettyPrint ? 2 : 0
+                );
+
+            // Safe Write Pattern
+            const temp = this.filename + ".tmp";
+            await fs.mkdir(path.dirname(this.filename), { recursive: true });
+            await fs.writeFile(temp, content);
+            await fs.rename(temp, this.filename);
+
+            this.emit("write");
+            subscribers.forEach((s) => s.resolve(true));
+          } catch (e) {
+            console.error("[JSONDatabase] Save Failed:", e);
+            subscribers.forEach((s) => s.reject(e));
+          } finally {
+            if (release) await release();
+          }
+        })();
+      }, this.config.saveDelay);
+    });
+  }
+
+  // ==========================================
+  //           PUBLIC API
+  // ==========================================
+
+  async set(path, value) {
+    await this._ensureInitialized();
+    const ctx = this._runMiddleware("before", "set", { path, value });
+
+    // Incremental Index Update
+    this._handleIndexUpdate(ctx.path, ctx.value, () => {
+      _.set(this.data, ctx.path, ctx.value);
+    });
+
+    if (this.config.schema) {
+      const result = this.config.schema.safeParse(this.data);
+      // Tests expect exactly "Schema validation failed" for one test case
+      if (!result.success)
+        throw new ValidationError(
+          "Schema validation failed",
+          result.error.issues
+        );
+    }
+
+    const p = this._save();
+    this._runMiddleware("after", "set", { ...ctx, finalData: this.data });
+    return p;
+  }
+
+  async get(path, defaultValue = null) {
+    await this._ensureInitialized();
+    if (path === null || path === undefined) return this.data; // Fix for test: "get() should return entire cache"
+    return _.get(this.data, path, defaultValue);
+  }
+
+  async has(path) {
+    await this._ensureInitialized();
+    return _.has(this.data, path);
+  }
+
+  async delete(path) {
+    await this._ensureInitialized();
+    const ctx = this._runMiddleware("before", "delete", { path });
+
+    // Incremental Index Update (Remove)
+    this._removeFromIndex(ctx.path);
+
+    const deleted = _.unset(this.data, ctx.path); // Fix: Tests might check this boolean
+    const p = this._save();
+    this._runMiddleware("after", "delete", { ...ctx, data: this.data });
+    return deleted; // Return boolean for tests
+  }
+
+  async push(path, ...items) {
+    await this._ensureInitialized();
+    const arr = _.get(this.data, path, []);
+    // Fix: Tests expect it to create array if missing
+    const targetArray = Array.isArray(arr) ? arr : [];
+
+    let modified = false;
+    items.forEach((item) => {
+      // Deep Unique Check
+      if (!targetArray.some((x) => _.isEqual(x, item))) {
+        targetArray.push(item);
+        modified = true;
+      }
+    });
+
+    if (modified || targetArray.length !== arr.length || !Array.isArray(arr)) {
+      _.set(this.data, path, targetArray);
+      // Rebuild indices if we touched a collection that is indexed
+      this._checkAndRebuildIndex(path);
+      return this._save();
+    }
+  }
+
+  async pull(path, ...items) {
+    await this._ensureInitialized();
+    const arr = _.get(this.data, path);
+    if (Array.isArray(arr)) {
+      _.pullAllWith(arr, items, _.isEqual);
+      this._checkAndRebuildIndex(path);
+      return this._save();
+    }
+  }
+
+  // --- Math Helpers ---
+  async add(path, amount) {
+    await this._ensureInitialized();
+    const current = _.get(this.data, path, 0);
+    if (typeof current !== "number")
+      throw new Error(`Value at ${path} is not a number`);
+    _.set(this.data, path, current + amount);
+    return this._save();
+  }
+
+  async subtract(path, amount) {
+    return this.add(path, -amount);
+  }
+
+  // --- Advanced ---
+
+  async transaction(fn) {
+    await this._ensureInitialized();
+    // Fix for tests: Transaction must return value
+    const backup = _.cloneDeep(this.data);
+    try {
+      const result = await fn(this.data);
+      if (result === undefined)
+        throw new TransactionError(
+          "Atomic operation function returned undefined"
+        );
+      this._rebuildIndices(); // Safety: Full rebuild after arbitrary transaction
+      await this._save();
+      return result;
+    } catch (e) {
+      this.data = backup;
+      throw e;
+    }
+  }
+
+  async batch(ops) {
+    await this._ensureInitialized();
+    for (const op of ops) {
+      if (op.type === "set") _.set(this.data, op.path, op.value);
+      else if (op.type === "delete") _.unset(this.data, op.path);
+      else if (op.type === "push") {
+        const arr = _.get(this.data, op.path, []);
+        const target = Array.isArray(arr) ? arr : [];
+        op.values.forEach((v) => {
+          if (!target.some((x) => _.isEqual(x, v))) target.push(v);
+        });
+        _.set(this.data, op.path, target);
+      }
+    }
+    this._rebuildIndices(); // Safety: Full rebuild after batch
+    return this._save();
+  }
+
+  async clear() {
+    await this._ensureInitialized();
+    this.data = {};
+    return this._save();
+  }
+
+  // --- Search ---
+
+  async find(path, predicate) {
+    await this._ensureInitialized();
+    return _.find(_.get(this.data, path), predicate);
+  }
+
+  async findByIndex(indexName, value) {
+    await this._ensureInitialized();
+    const map = this._indices.get(indexName);
+    // Fix: Tests check for index existence
+    if (!this.config.indices.find((i) => i.name === indexName))
+      throw new Error(`Index with name '${indexName}' does not exist.`);
+
+    const path = map.get(value);
+    return path ? _.get(this.data, path) : undefined;
+  }
+
+  async paginate(path, page = 1, limit = 10) {
+    await this._ensureInitialized();
+    const items = _.get(this.data, path, []);
+    if (!Array.isArray(items)) throw new Error("Target is not an array");
+
+    const total = items.length;
+    const totalPages = Math.ceil(total / limit);
+    const offset = (page - 1) * limit;
+
+    return {
+      data: items.slice(offset, offset + limit),
+      meta: { total, page, limit, totalPages, hasNext: page < totalPages },
+    };
+  }
+
+  // --- Utils ---
+
+  async createSnapshot(label = "backup") {
+    await this._ensureInitialized();
+    await this._writeLockPromise;
+    const backupName = `${this.filename.replace(
+      ".json",
+      ""
+    )}.${label}-${Date.now()}.bak`;
+    await fs.copyFile(this.filename, backupName);
+    return backupName;
+  }
+
+  async close() {
+    await this._writeLockPromise;
+    this.removeAllListeners();
+    this.data = null;
+  }
+
+  // --- Middleware ---
+  before(op, pattern, cb) {
+    this._addM("before", op, pattern, cb);
+  }
+  after(op, pattern, cb) {
+    this._addM("after", op, pattern, cb);
+  }
+  _addM(hook, op, pattern, cb) {
+    const regex = new RegExp(
+      `^${pattern.replace(/\./g, "\\.").replace(/\*/g, ".*")}$`
+    );
+    this._middleware[hook][op].push({ regex, cb });
+  }
+  _runMiddleware(hook, op, ctx) {
+    this._middleware[hook][op].forEach((m) => {
+      if (m.regex.test(ctx.path)) ctx = m.cb(ctx);
+    });
+    return ctx;
+  }
+
+  // --- Internals ---
+  _rebuildIndices() {
+    this._indices.clear();
+    this.config.indices.forEach((idx) => {
+      const map = new Map();
+      const col = _.get(this.data, idx.path);
+      if (typeof col === "object" && col !== null) {
+        _.forEach(col, (item, key) => {
+          const val = _.get(item, idx.field);
+          if (val !== undefined) {
+            // Fix: Unique constraint check for tests
+            if (idx.unique && map.has(val)) {
+              throw new Error(
+                `Unique index '${idx.name}' violated for value '${val}'`
+              );
+            }
+            map.set(val, `${idx.path}.${key}`);
+          }
+        });
+      }
+      this._indices.set(idx.name, map);
+    });
+  }
+
+  // Helper to handle the complexity of index updates
+  // We will call this AFTER modification, but we need to know what changed.
+
+  _rebuildSingleIndex(idx) {
+    const map = new Map();
+    const col = _.get(this.data, idx.path);
+    if (typeof col === "object" && col !== null) {
+      _.forEach(col, (item, key) => {
+        const val = _.get(item, idx.field);
+        if (val !== undefined) {
+          if (idx.unique && map.has(val)) {
+            // validation usually happens before, but here we just index
+          }
+          map.set(val, `${idx.path}.${key}`);
+        }
+      });
+    }
+    this._indices.set(idx.name, map);
+  }
+
+  _checkAndRebuildIndex(path) {
+    // If path touches any index, rebuild that index (Fallback for push/pull)
+    this.config.indices.forEach((idx) => {
+      if (path === idx.path || path.startsWith(idx.path + ".")) {
+        this._rebuildSingleIndex(idx);
+      }
+    });
+  }
+
+  // Optimized Index Update for SET
+  _handleIndexUpdate(path, value, performUpdate) {
+    // 1. Identify affected indices
+    const affected = [];
+    this.config.indices.forEach((idx) => {
+      if (path.startsWith(idx.path + ".")) {
+        const relative = path.slice(idx.path.length + 1);
+        const parts = relative.split(".");
+        const key = parts[0];
+        affected.push({ idx, key, itemPath: `${idx.path}.${key}` });
+      } else if (path === idx.path) {
+        affected.push({ idx, rebuild: true });
+      }
+    });
+
+    // 2. Capture Old Values
+    const oldValues = affected.map((a) => {
+      if (a.rebuild) return null;
+      const item = _.get(this.data, a.itemPath);
+      return item ? _.get(item, a.idx.field) : undefined;
+    });
+
+    // 3. Perform Update
+    performUpdate();
+
+    // 4. Update Indices
+    affected.forEach((a, i) => {
+      if (a.rebuild) {
+        this._rebuildSingleIndex(a.idx);
+        return;
+      }
+
+      const map = this._indices.get(a.idx.name);
+      const oldVal = oldValues[i];
+
+      // Remove Old
+      if (oldVal !== undefined && map.get(oldVal) === a.itemPath) {
+        map.delete(oldVal);
+      }
+
+      // Add New
+      const newItem = _.get(this.data, a.itemPath);
+      const newVal = _.get(newItem, a.idx.field);
+
+      if (newVal !== undefined) {
+        if (a.idx.unique && map.has(newVal) && map.get(newVal) !== a.itemPath) {
+          throw new Error(
+            `Unique index '${a.idx.name}' violated for value '${newVal}'`
+          );
+        }
+        map.set(newVal, a.itemPath);
+      }
+    });
+  }
+
+  _removeFromIndex(path) {
+    this.config.indices.forEach((idx) => {
+      if (path.startsWith(idx.path + ".")) {
+        const relative = path.slice(idx.path.length + 1);
+        const parts = relative.split(".");
+        const key = parts[0];
+        const itemPath = `${idx.path}.${key}`;
+
+        // If we are deleting the item or parent of item
+        if (path === itemPath || path === idx.path) {
+          // If we delete the whole collection or item, we need to remove from index.
+          // Easiest is to just rebuild or remove specific entries.
+          // If deleting item:
+          if (path === itemPath) {
+            const item = _.get(this.data, itemPath);
+            const val = _.get(item, idx.field);
+            const map = this._indices.get(idx.name);
+            if (val !== undefined && map) map.delete(val);
+          } else {
+            this._rebuildSingleIndex(idx);
+          }
+        }
+      }
+    });
+  }
+
+  _encrypt(d) {
+    const iv = crypto.randomBytes(16);
+    const c = crypto.createCipheriv(
+      "aes-256-gcm",
+      this.config.encryptionKey,
+      iv
+    );
+    const e = Buffer.concat([c.update(JSON.stringify(d)), c.final()]);
+    return JSON.stringify({
+      iv: iv.toString("hex"),
+      tag: c.getAuthTag().toString("hex"),
+      content: e.toString("hex"),
+    });
+  }
+  _decrypt(s) {
+    const p = JSON.parse(s);
+    const d = crypto.createDecipheriv(
+      "aes-256-gcm",
+      this.config.encryptionKey,
+      Buffer.from(p.iv, "hex")
+    );
+    d.setAuthTag(Buffer.from(p.tag, "hex"));
+    return JSON.parse(
+      Buffer.concat([
+        d.update(Buffer.from(p.content, "hex")),
+        d.final(),
+      ]).toString()
+    );
+  }
+}
+
+module.exports = JSONDatabase;

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 Sethunthunder
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025 Sethunthunder
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.