json-database-st 1.0.7 → 1.0.9

package/JSONDatabase.js

@@ -1,11 +1,13 @@
 // File: JSONDatabase.js
 // Final, Complete, and Secure Version (Patched)
 
-const fs = require('fs').promises;
-const path = require('path');
-const crypto = require('crypto');
-const _ = require('lodash');
-const EventEmitter = require('events');
+const fs = require("fs").promises;
+const path = require("path");
+const crypto = require("crypto");
+const _ = require("lodash");
+const EventEmitter = require("events");
+// --- FIX: Add dependency for cross-process file locking. Run `npm install proper-lockfile`.
+const lockfile = require("proper-lockfile");
 
 // --- Custom Error Classes for Better Error Handling ---
 
@@ -32,7 +34,6 @@ class IndexViolationError extends DBError {}
 /** Error for security-related issues like path traversal or bad keys. */
 class SecurityError extends DBError {}
 
-
 // --- Type Definitions for Clarity ---
 
 /**
@@ -74,13 +75,11 @@ class SecurityError extends DBError {}
  * @property {boolean} [unique=false] - If true, enforces that the indexed field must be unique across the collection.
  */
 
-
 // --- Cryptography Constants ---
-const ALGORITHM = 'aes-256-gcm';
+const ALGORITHM = "aes-256-gcm";
 const IV_LENGTH = 16;
 const AUTH_TAG_LENGTH = 16;
 
-
 /**
  * A robust, secure, promise-based JSON file database with atomic operations, indexing, schema validation, and events.
  * Includes encryption-at-rest and path traversal protection.
@@ -109,13 +108,23 @@ class JSONDatabase extends EventEmitter {
     const resolvedPath = path.resolve(filename);
     const workingDir = process.cwd();
     if (!resolvedPath.startsWith(workingDir)) {
-      throw new SecurityError(`Path traversal detected. Database path must be within the project directory: ${workingDir}`);
+      throw new SecurityError(
+        `Path traversal detected. Database path must be within the project directory: ${workingDir}`
+      );
     }
-    this.filename = /\.json$/.test(resolvedPath) ? resolvedPath : `${resolvedPath}.json`;
+    this.filename = /\.json$/.test(resolvedPath)
+      ? resolvedPath
+      : `${resolvedPath}.json`;
 
     // --- Security Check: Encryption Key ---
-    if (options.encryptionKey && (!options.encryptionKey || Buffer.from(options.encryptionKey, 'hex').length !== 32)) {
-      throw new SecurityError('Encryption key must be a 32-byte (64-character hex) string.');
+    if (
+      options.encryptionKey &&
+      (!options.encryptionKey ||
+        Buffer.from(options.encryptionKey, "hex").length !== 32)
+    ) {
+      throw new SecurityError(
+        "Encryption key must be a 32-byte (64-character hex) string."
+      );
     }
 
     this.config = {
@@ -123,7 +132,9 @@ class JSONDatabase extends EventEmitter {
       writeOnChange: options.writeOnChange !== false,
       schema: options.schema || null,
       indices: options.indices || [],
-      encryptionKey: options.encryptionKey ? Buffer.from(options.encryptionKey, 'hex') : null,
+      encryptionKey: options.encryptionKey
+        ? Buffer.from(options.encryptionKey, "hex")
+        : null,
     };
 
     this.cache = null;
@@ -138,29 +149,44 @@ class JSONDatabase extends EventEmitter {
   // --- Encryption & Decryption ---
   _encrypt(data) {
     const iv = crypto.randomBytes(IV_LENGTH);
-    const cipher = crypto.createCipheriv(ALGORITHM, this.config.encryptionKey, iv);
+    const cipher = crypto.createCipheriv(
+      ALGORITHM,
+      this.config.encryptionKey,
+      iv
+    );
     const jsonString = JSON.stringify(data);
-    const encrypted = Buffer.concat([cipher.update(jsonString, 'utf8'), cipher.final()]);
+    const encrypted = Buffer.concat([
+      cipher.update(jsonString, "utf8"),
+      cipher.final(),
+    ]);
     const authTag = cipher.getAuthTag();
     return JSON.stringify({
-      iv: iv.toString('hex'),
-      tag: authTag.toString('hex'),
-      content: encrypted.toString('hex'),
+      iv: iv.toString("hex"),
+      tag: authTag.toString("hex"),
+      content: encrypted.toString("hex"),
     });
   }
 
   _decrypt(encryptedPayload) {
     try {
       const payload = JSON.parse(encryptedPayload);
-      const iv = Buffer.from(payload.iv, 'hex');
-      const authTag = Buffer.from(payload.tag, 'hex');
-      const encryptedContent = Buffer.from(payload.content, 'hex');
-      const decipher = crypto.createDecipheriv(ALGORITHM, this.config.encryptionKey, iv);
+      const iv = Buffer.from(payload.iv, "hex");
+      const authTag = Buffer.from(payload.tag, "hex");
+      const encryptedContent = Buffer.from(payload.content, "hex");
+      const decipher = crypto.createDecipheriv(
+        ALGORITHM,
+        this.config.encryptionKey,
+        iv
+      );
       decipher.setAuthTag(authTag);
-      const decrypted = decipher.update(encryptedContent, 'hex', 'utf8') + decipher.final('utf8');
+      const decrypted =
+        decipher.update(encryptedContent, "hex", "utf8") +
+        decipher.final("utf8");
       return JSON.parse(decrypted);
     } catch (e) {
-      throw new SecurityError('Decryption failed. The file may be corrupted, tampered with, or the encryption key is incorrect.');
+      throw new SecurityError(
+        "Decryption failed. The file may be corrupted, tampered with, or the encryption key is incorrect."
+      );
     }
   }
 
@@ -168,13 +194,38 @@ class JSONDatabase extends EventEmitter {
 
   /** @private Kicks off the initialization process. */
   async _initialize() {
+    // --- FIX: Crash Recovery for Durable Writes ---
+    // Check if a temporary file exists from a previously failed write.
+    // If so, it represents the most recent state. We recover by renaming it.
+    const tempFile = this.filename + ".tmp";
+    try {
+      await fs.access(tempFile);
+      console.warn(
+        `[JSONDatabase] Found temporary file ${tempFile}. Recovering from a previous failed write.`
+      );
+      await fs.rename(tempFile, this.filename);
+      console.log(
+        `[JSONDatabase] Recovery successful. ${this.filename} has been restored.`
+      );
+    } catch (e) {
+      // This is the normal case where no temp file exists. Do nothing.
+    }
+
     try {
       await this._refreshCache();
       this._rebuildAllIndices();
     } catch (err) {
-      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);
+      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;
     }
   }
@@ -182,22 +233,25 @@ class JSONDatabase extends EventEmitter {
   /** @private Reads file, decrypts if necessary, and populates cache. */
   async _refreshCache() {
     try {
-      const fileContent = await fs.readFile(this.filename, 'utf8');
+      const fileContent = await fs.readFile(this.filename, "utf8");
       if (this.config.encryptionKey) {
-        this.cache = fileContent.trim() === '' ? {} : this._decrypt(fileContent);
+        this.cache =
+          fileContent.trim() === "" ? {} : this._decrypt(fileContent);
       } else {
-        this.cache = fileContent.trim() === '' ? {} : JSON.parse(fileContent);
+        this.cache = fileContent.trim() === "" ? {} : JSON.parse(fileContent);
       }
       this.stats.reads++;
     } catch (err) {
-      if (err.code === 'ENOENT') {
-        console.warn(`[JSONDatabase] File ${this.filename} not found. Creating.`);
+      if (err.code === "ENOENT") {
+        console.warn(
+          `[JSONDatabase] File ${this.filename} not found. Creating.`
+        );
         this.cache = {};
-        const initialContent = this.config.encryptionKey ? this._encrypt({}) : '{}';
-        await fs.writeFile(this.filename, initialContent, 'utf8');
-        this.stats.writes++;
+        // Do not write file here; _atomicWrite will create it safely.
       } else if (err instanceof SyntaxError && !this.config.encryptionKey) {
-        throw new DBInitializationError(`Failed to parse JSON from ${this.filename}. File is corrupted.`);
+        throw new DBInitializationError(
+          `Failed to parse JSON from ${this.filename}. File is corrupted.`
+        );
       } else {
         throw err; // Re-throw security, crypto, and other errors
       }
@@ -206,137 +260,171 @@ class JSONDatabase extends EventEmitter {
 
   /** @private Ensures all operations wait for initialization to complete. */
   async _ensureInitialized() {
-      return this._initPromise;
+    // This promise will be rejected if _initialize() fails, stopping all operations.
+    return this._initPromise;
   }
 
   /** @private Performs an atomic write operation. */
   async _atomicWrite(operationFn) {
     await this._ensureInitialized();
 
+    // This promise chain ensures all writes *from this process* happen one after another.
     this.writeLock = this.writeLock.then(async () => {
-      const oldData = this.cache;
-      const dataToModify = _.cloneDeep(oldData);
-
+      let releaseLock;
       try {
-        // --- FIX: Await the operation function in case it's async ---
+        // --- FIX: Acquire a cross-process lock to prevent race conditions.
+        // This will wait if another process (or this one) currently holds the lock.
+        releaseLock = await lockfile.lock(this.filename, {
+          stale: 7000, // Lock is considered stale after 7s
+          retries: {
+            retries: 5,
+            factor: 1.2,
+            minTimeout: 200,
+          },
+        });
+
+        // --- FIX: Refresh cache *after* acquiring the lock.
+        // This is critical to get the latest data if another process changed it.
+        await this._refreshCache();
+
+        const oldData = this.cache;
+        const dataToModify = _.cloneDeep(oldData);
+
         const newData = await operationFn(dataToModify);
 
         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) {
           const validationResult = this.config.schema.safeParse(newData);
           if (!validationResult.success) {
-            throw new ValidationError('Schema validation failed.', validationResult.error.issues);
+            throw new ValidationError(
+              "Schema validation failed.",
+              validationResult.error.issues
+            );
           }
         }
 
+        this._updateIndices(oldData, newData);
+
         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)
           : JSON.stringify(newData, null, this.config.prettyPrint ? 2 : 0);
-        
-        await fs.writeFile(this.filename, contentToWrite, 'utf8');
+
+        // --- FIX: Implement durable write. Write to temp file first.
+        const tempFile = this.filename + ".tmp";
+        await fs.writeFile(tempFile, contentToWrite, "utf8");
+        // --- FIX: Atomically rename temp file to the final filename.
+        await fs.rename(tempFile, this.filename);
 
         this.cache = newData;
         this.stats.writes++;
-        
-        this.emit('write', { filename: this.filename, timestamp: Date.now() });
-        this.emit('change', { oldValue: oldData, newValue: newData });
 
-        return newData;
+        this.emit("write", { filename: this.filename, timestamp: Date.now() });
+        this.emit("change", { oldValue: oldData, newValue: newData });
 
+        return newData;
       } catch (error) {
-        this.emit('error', error);
-        console.error("[JSONDatabase] Atomic write failed. No changes were saved.", error);
+        this.emit("error", error);
+        console.error(
+          "[JSONDatabase] Atomic write failed. No changes were saved.",
+          error
+        );
         throw error;
+      } finally {
+        // --- FIX: Always release the lock, even if an error occurred.
+        if (releaseLock) {
+          await releaseLock();
+        }
       }
     });
 
     return this.writeLock;
   }
-  
+
   // --- Indexing ---
 
   /** @private Clears and rebuilds all defined indices from the current cache. */
   _rebuildAllIndices() {
-      this._indices.clear();
-      for (const indexDef of this.config.indices) {
-          this._indices.set(indexDef.name, new Map());
-      }
-      if (this.config.indices.length > 0 && !_.isEmpty(this.cache)) {
-          this._updateIndices({}, this.cache); // Treat it as a full "add" operation
-      }
-      console.log(`[JSONDatabase] Rebuilt ${this.config.indices.length} indices for ${this.filename}.`);
+    this._indices.clear();
+    for (const indexDef of this.config.indices) {
+      this._indices.set(indexDef.name, new Map());
+    }
+    if (this.config.indices.length > 0 && !_.isEmpty(this.cache)) {
+      // Rebuild by treating the current state as "new" and the previous state as empty.
+      this._updateIndices({}, this.cache);
+    }
+    console.log(
+      `[JSONDatabase] Rebuilt ${this.config.indices.length} indices for ${this.filename}.`
+    );
   }
 
-  /** @private Compares old and new data to update indices efficiently. */
+  /**
+   * @private Compares old and new data to update indices efficiently.
+   * FIX: Replaced inefficient and buggy index update logic with a robust key-based comparison.
+   * This new implementation correctly handles additions, deletions, and in-place updates,
+   * and is significantly more performant.
+   */
   _updateIndices(oldData, newData) {
-      for (const indexDef of this.config.indices) {
-          const collectionPath = indexDef.path;
-          const field = indexDef.field;
-          const indexMap = this._indices.get(indexDef.name);
-
-          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]);
-              }
-          }
+    for (const indexDef of this.config.indices) {
+      const indexMap = this._indices.get(indexDef.name);
+      if (!indexMap) continue;
 
-          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 oldCollection = _.get(oldData, indexDef.path, {});
+      const newCollection = _.get(newData, indexDef.path, {});
+
+      if (!_.isObject(oldCollection) || !_.isObject(newCollection)) {
+        continue; // Indexing requires a collection (object or array).
+      }
+
+      const allKeys = _.union(_.keys(oldCollection), _.keys(newCollection));
+
+      for (const key of allKeys) {
+        const oldItem = oldCollection[key];
+        const newItem = newCollection[key];
+
+        if (_.isEqual(oldItem, newItem)) {
+          continue; // Item is unchanged, no index update needed.
+        }
 
-          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);
-                  }
-              }
+        const oldVal = oldItem?.[indexDef.field];
+        const newVal = newItem?.[indexDef.field];
+
+        if (_.isEqual(oldVal, newVal)) {
+          continue; // Indexed field's value is unchanged.
+        }
+
+        // 1. Remove the old value if it was indexed and pointed to this item.
+        if (oldVal !== undefined && indexMap.get(oldVal) === key) {
+          indexMap.delete(oldVal);
+        }
+
+        // 2. Add the new value if it's defined.
+        if (newVal !== undefined) {
+          // Check for unique constraint violation before adding.
+          if (indexDef.unique && indexMap.has(newVal)) {
+            throw new IndexViolationError(
+              `Unique index '${indexDef.name}' violated for value '${newVal}'.`
+            );
           }
+          indexMap.set(newVal, key);
+        }
       }
+    }
   }
 
-
   // --- Public API ---
 
   async get(path, defaultValue) {
     await this._ensureInitialized();
     this.stats.cacheHits++;
-    // --- FIX: Handle undefined/null path to get the entire object ---
     if (path === undefined || path === null) {
       return this.cache;
     }
@@ -350,7 +438,7 @@ class JSONDatabase extends EventEmitter {
   }
 
   async set(path, value) {
-    await this._atomicWrite(data => {
+    return this._atomicWrite((data) => {
       _.set(data, path, value);
       return data;
     });
@@ -358,7 +446,7 @@ class JSONDatabase extends EventEmitter {
 
   async delete(path) {
     let deleted = false;
-    await this._atomicWrite(data => {
+    await this._atomicWrite((data) => {
       deleted = _.unset(data, path);
       return data;
     });
@@ -367,11 +455,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 => {
-        if (!targetArray.some(existing => _.isEqual(existing, item))) {
+      items.forEach((item) => {
+        if (!targetArray.some((existing) => _.isEqual(existing, item))) {
           targetArray.push(item);
         }
       });
@@ -382,7 +470,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,43 +486,49 @@ 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.");
-          
+          if (!op || !op.type || op.path === undefined)
+            throw new Error("Invalid operation format: missing type or path.");
+
           switch (op.type) {
-            case 'set':
-              if (!op.hasOwnProperty('value')) throw new Error("Set operation missing 'value'.");
+            case "set":
+              if (!op.hasOwnProperty("value"))
+                throw new Error("Set operation missing 'value'.");
               _.set(data, op.path, op.value);
               break;
-            case 'delete':
+            case "delete":
               _.unset(data, op.path);
               break;
-            case 'push':
-              if (!Array.isArray(op.values)) throw new Error("Push operation 'values' must be an array.");
+            case "push":
+              if (!Array.isArray(op.values))
+                throw new Error("Push operation 'values' must be an array.");
               const arr = _.get(data, op.path);
               const targetArray = Array.isArray(arr) ? arr : [];
-              op.values.forEach(item => {
-                  if (!targetArray.some(existing => _.isEqual(existing, item))) targetArray.push(item);
+              op.values.forEach((item) => {
+                if (!targetArray.some((existing) => _.isEqual(existing, item)))
+                  targetArray.push(item);
               });
               _.set(data, op.path, targetArray);
               break;
-            case 'pull':
-              if (!Array.isArray(op.values)) throw new Error("Pull operation 'values' must be an array.");
+            case "pull":
+              if (!Array.isArray(op.values))
+                throw new Error("Pull operation 'values' must be an array.");
               const pullArr = _.get(data, op.path);
-              if (Array.isArray(pullArr)) _.pullAllWith(pullArr, op.values, _.isEqual);
+              if (Array.isArray(pullArr))
+                _.pullAllWith(pullArr, op.values, _.isEqual);
               break;
             default:
               throw new Error(`Unsupported operation type: '${op.type}'.`);
           }
         } catch (err) {
-            const errorMessage = `[JSONDatabase] Batch failed at operation index ${index} (type: ${op?.type}): ${err.message}`;
-            if (options.stopOnError) {
-                throw new Error(errorMessage);
-            } else {
-                console.error(errorMessage);
-            }
+          const errorMessage = `[JSONDatabase] Batch failed at operation index ${index} (type: ${op?.type}): ${err.message}`;
+          if (options.stopOnError) {
+            throw new Error(errorMessage);
+          } else {
+            console.error(errorMessage);
+          }
         }
       }
       return data;
@@ -442,33 +536,36 @@ class JSONDatabase extends EventEmitter {
   }
 
   async find(collectionPath, predicate) {
-      await this._ensureInitialized();
-      const collection = _.get(this.cache, collectionPath);
-      if (typeof collection !== 'object' || collection === null) return undefined;
-      
-      this.stats.cacheHits++;
-      return _.find(collection, predicate);
+    await this._ensureInitialized();
+    const collection = _.get(this.cache, collectionPath);
+    if (typeof collection !== "object" || collection === null) return undefined;
+
+    this.stats.cacheHits++;
+    return _.find(collection, predicate);
   }
-  
+
   async findByIndex(indexName, value) {
-      await this._ensureInitialized();
-      if (!this._indices.has(indexName)) {
-          throw new Error(`Index with name '${indexName}' does not exist.`);
-      }
+    await this._ensureInitialized();
+    if (!this._indices.has(indexName)) {
+      throw new Error(`Index with name '${indexName}' does not exist.`);
+    }
 
-      this.stats.cacheHits++;
-      const indexMap = this._indices.get(indexName);
-      const objectKey = indexMap.get(value);
+    this.stats.cacheHits++;
+    const indexMap = this._indices.get(indexName);
+    const objectKey = indexMap.get(value);
 
-      if (objectKey === undefined) return undefined;
+    if (objectKey === undefined) return undefined;
 
-      const indexDef = this.config.indices.find(i => i.name === indexName);
-      return _.get(this.cache, [..._.toPath(indexDef.path), objectKey]);
+    const indexDef = this.config.indices.find((i) => i.name === indexName);
+    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() {
@@ -477,15 +574,17 @@ class JSONDatabase extends EventEmitter {
 
   async close() {
     await this.writeLock;
-    
+
     this.cache = null;
     this._indices.clear();
     this.removeAllListeners();
     this._initPromise = null;
 
     const finalStats = JSON.stringify(this.getStats());
-    console.log(`[JSONDatabase] Closed connection to ${this.filename}. Final Stats: ${finalStats}`);
+    console.log(
+      `[JSONDatabase] Closed connection to ${this.filename}. Final Stats: ${finalStats}`
+    );
   }
 }
 
-module.exports = JSONDatabase;
+module.exports = JSONDatabase;

package/package.json

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