json-database-st 1.0.7 → 1.0.8

package/JSONDatabase.js

@@ -175,6 +175,9 @@ class JSONDatabase extends EventEmitter {
       const initError = new DBInitializationError(`Failed to initialize database: ${err.message}`);
       this.emit('error', initError);
       console.error(`[JSONDatabase] FATAL: Initialization failed for ${this.filename}. The database is in an unusable state.`, err);
+      // --- ENHANCEMENT: Make the instance unusable if init fails ---
+      // By re-throwing here, the _initPromise will be rejected, and all subsequent
+      // operations waiting on _ensureInitialized() will fail immediately.
       throw initError;
     }
   }
@@ -206,6 +209,7 @@ class JSONDatabase extends EventEmitter {
 
   /** @private Ensures all operations wait for initialization to complete. */
   async _ensureInitialized() {
+      // This promise will be rejected if _initialize() fails, stopping all operations.
       return this._initPromise;
   }
 
@@ -213,16 +217,19 @@ class JSONDatabase extends EventEmitter {
   async _atomicWrite(operationFn) {
     await this._ensureInitialized();
 
+    // This promise chain ensures all writes happen one after another.
     this.writeLock = this.writeLock.then(async () => {
+      // Use the live cache as the source of truth for the transaction.
       const oldData = this.cache;
       const dataToModify = _.cloneDeep(oldData);
 
       try {
-        // --- FIX: Await the operation function in case it's async ---
+        // --- CRITICAL FIX: Await the operation function in case it's async ---
         const newData = await operationFn(dataToModify);
 
+        // --- ENHANCEMENT: Stricter check to prevent accidental data loss ---
         if (newData === undefined) {
-          throw new TransactionError("Atomic operation function returned undefined. Aborting to prevent data loss.");
+          throw new TransactionError("Atomic operation function returned undefined. Aborting to prevent data loss. Did you forget to `return data`?");
         }
 
         if (this.config.schema) {
@@ -231,12 +238,15 @@ class JSONDatabase extends EventEmitter {
             throw new ValidationError('Schema validation failed.', validationResult.error.issues);
           }
         }
+        
+        // --- ENHANCEMENT: Update indices *before* the write to catch violations early ---
+        // This will throw an IndexViolationError if there's a problem.
+        this._updateIndices(oldData, newData);
 
+        // Only write to disk if data has actually changed.
         if (this.config.writeOnChange && _.isEqual(newData, oldData)) {
-          return oldData;
+          return oldData; // Return the unchanged data
         }
-        
-        this._updateIndices(oldData, newData);
 
         const contentToWrite = this.config.encryptionKey
           ? this._encrypt(newData)
@@ -244,6 +254,7 @@ class JSONDatabase extends EventEmitter {
         
         await fs.writeFile(this.filename, contentToWrite, 'utf8');
 
+        // Update cache only after a successful write.
         this.cache = newData;
         this.stats.writes++;
         
@@ -253,9 +264,11 @@ class JSONDatabase extends EventEmitter {
         return newData;
 
       } catch (error) {
+        // If any part of the transaction fails, emit the error and re-throw.
+        // The cache remains unchanged from before the operation.
         this.emit('error', error);
         console.error("[JSONDatabase] Atomic write failed. No changes were saved.", error);
-        throw error;
+        throw error; // Propagate the error to the caller.
       }
     });
 
@@ -283,49 +296,33 @@ class JSONDatabase extends EventEmitter {
           const field = indexDef.field;
           const indexMap = this._indices.get(indexDef.name);
 
-          const oldCollection = _.get(oldData, collectionPath, {});
-          const newCollection = _.get(newData, collectionPath, {});
+          const oldCollection = _.get(oldData, collectionPath, []);
+          const newCollection = _.get(newData, collectionPath, []);
 
-          const oldKeys = Object.keys(oldCollection);
-          const newKeys = Object.keys(newCollection);
-          
-          const addedKeys = _.difference(newKeys, oldKeys);
-          const removedKeys = _.difference(oldKeys, newKeys);
-          const potentiallyModifiedKeys = _.intersection(oldKeys, newKeys);
-          
-          for (const key of removedKeys) {
-              const oldItem = oldCollection[key];
-              if (oldItem && oldItem[field] !== undefined) {
-                  indexMap.delete(oldItem[field]);
-              }
-          }
+          // This logic works for both arrays of objects and objects of objects (maps)
+          const oldItems = _.values(oldCollection);
+          const newItems = _.values(newCollection);
 
-          for (const key of addedKeys) {
-              const newItem = newCollection[key];
-              const indexValue = newItem?.[field];
-              if (indexValue !== undefined) {
-                  if (indexDef.unique && indexMap.has(indexValue)) {
-                      throw new IndexViolationError(`Unique index '${indexDef.name}' violated for value '${indexValue}'.`);
-                  }
-                  indexMap.set(indexValue, key);
+          const oldMap = new Map(oldItems.map(item => [item[field], item]));
+          const newMap = new Map(newItems.map(item => [item[field], item]));
+
+          // Find values that were removed or changed
+          for (const [oldValue, oldItem] of oldMap.entries()) {
+              if (oldValue !== undefined && !newMap.has(oldValue)) {
+                  indexMap.delete(oldValue);
               }
           }
-
-          for (const key of potentiallyModifiedKeys) {
-              const oldItem = oldCollection[key];
-              const newItem = newCollection[key];
-              const oldIndexValue = oldItem?.[field];
-              const newIndexValue = newItem?.[field];
-              
-              if (!_.isEqual(oldItem, newItem) && oldIndexValue !== newIndexValue) {
-                  if (oldIndexValue !== undefined) indexMap.delete(oldIndexValue);
-                  if (newIndexValue !== undefined) {
-                      if (indexDef.unique && indexMap.has(newIndexValue)) {
-                          throw new IndexViolationError(`Unique index '${indexDef.name}' violated for value '${newIndexValue}'.`);
-                      }
-                      indexMap.set(newIndexValue, key);
+          
+          // Find values that were added or changed
+          for (const [newValue, newItem] of newMap.entries()) {
+               if (newValue !== undefined && !oldMap.has(newValue)) {
+                  if (indexDef.unique && indexMap.has(newValue)) {
+                      throw new IndexViolationError(`Unique index '${indexDef.name}' violated for value '${newValue}'.`);
                   }
-              }
+                  // To find the key, we need to iterate, which isn't ideal but necessary here.
+                  const key = _.findKey(newCollection, {[field]: newValue});
+                  indexMap.set(newValue, key);
+               }
           }
       }
   }
@@ -336,7 +333,7 @@ class JSONDatabase extends EventEmitter {
   async get(path, defaultValue) {
     await this._ensureInitialized();
     this.stats.cacheHits++;
-    // --- FIX: Handle undefined/null path to get the entire object ---
+    // --- CRITICAL FIX: Handle undefined/null path to get the entire object ---
     if (path === undefined || path === null) {
       return this.cache;
     }
@@ -350,7 +347,7 @@ class JSONDatabase extends EventEmitter {
   }
 
   async set(path, value) {
-    await this._atomicWrite(data => {
+    return this._atomicWrite(data => {
       _.set(data, path, value);
       return data;
     });
@@ -367,10 +364,11 @@ class JSONDatabase extends EventEmitter {
 
   async push(path, ...items) {
     if (items.length === 0) return;
-    await this._atomicWrite(data => {
+    return this._atomicWrite(data => {
       const arr = _.get(data, path);
       const targetArray = Array.isArray(arr) ? arr : [];
       items.forEach(item => {
+        // Use deep comparison to ensure object uniqueness
         if (!targetArray.some(existing => _.isEqual(existing, item))) {
           targetArray.push(item);
         }
@@ -382,7 +380,7 @@ class JSONDatabase extends EventEmitter {
 
   async pull(path, ...itemsToRemove) {
     if (itemsToRemove.length === 0) return;
-    await this._atomicWrite(data => {
+    return this._atomicWrite(data => {
       const arr = _.get(data, path);
       if (Array.isArray(arr)) {
         _.pullAllWith(arr, itemsToRemove, _.isEqual);
@@ -398,7 +396,7 @@ class JSONDatabase extends EventEmitter {
   async batch(ops, options = { stopOnError: false }) {
     if (!Array.isArray(ops) || ops.length === 0) return;
 
-    await this._atomicWrite(data => {
+    return this._atomicWrite(data => {
       for (const [index, op] of ops.entries()) {
         try {
           if (!op || !op.type || op.path === undefined) throw new Error("Invalid operation format: missing type or path.");
@@ -444,6 +442,7 @@ class JSONDatabase extends EventEmitter {
   async find(collectionPath, predicate) {
       await this._ensureInitialized();
       const collection = _.get(this.cache, collectionPath);
+      // Works for both objects and arrays
       if (typeof collection !== 'object' || collection === null) return undefined;
       
       this.stats.cacheHits++;
@@ -463,12 +462,14 @@ class JSONDatabase extends EventEmitter {
       if (objectKey === undefined) return undefined;
 
       const indexDef = this.config.indices.find(i => i.name === indexName);
-      return _.get(this.cache, [..._.toPath(indexDef.path), objectKey]);
+      // Construct the full path to the object
+      const fullPath = [..._.toPath(indexDef.path), objectKey];
+      return _.get(this.cache, fullPath);
   }
 
   async clear() {
-    console.warn(`[JSONDatabase] Clearing all data from ${this.filename}.`);
-    await this._atomicWrite(() => ({}));
+    console.warn(`[JSONDatabase] Clearing all data from ${this.filename}. This action is irreversible.`);
+    return this._atomicWrite(() => ({}));
   }
 
   getStats() {
@@ -476,12 +477,13 @@ class JSONDatabase extends EventEmitter {
   }
 
   async close() {
+    // Wait for the last pending write operation to finish
     await this.writeLock;
     
     this.cache = null;
     this._indices.clear();
     this.removeAllListeners();
-    this._initPromise = null;
+    this._initPromise = null; // Allow for garbage collection
 
     const finalStats = JSON.stringify(this.getStats());
     console.log(`[JSONDatabase] Closed connection to ${this.filename}. Final Stats: ${finalStats}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-database-st",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "A simple, promise-based JSON file database for Node.js with atomic operations and lodash integration.",
   "main": "JSONDatabase.js",
   "scripts": {