@frogfish/k2db 1.0.8 → 1.0.10

package/data.d.ts

@@ -33,13 +33,13 @@ export declare class K2Data {
     /**
      * Updates multiple documents based on criteria.
      */
-    updateAll(collectionName: string, criteria: any, values: Partial<BaseDocument>, replace?: boolean): Promise<{
+    updateAll(collectionName: string, criteria: any, values: Partial<BaseDocument>): Promise<{
         updated: number;
     }>;
     /**
      * Updates a single document by UUID.
      */
-    update(collectionName: string, id: string, data: Partial<BaseDocument>, replace?: boolean, objectTypeName?: string): Promise<{
+    update(collectionName: string, id: string, data: Partial<BaseDocument>, replace?: boolean): Promise<{
         updated: number;
     }>;
     /**

package/data.js

@@ -44,16 +44,16 @@ class K2Data {
     /**
      * Updates multiple documents based on criteria.
      */
-    async updateAll(collectionName, criteria, values, replace = false) {
+    async updateAll(collectionName, criteria, values) {
         // Ensure it returns { updated: number }
-        return this.db.updateAll(collectionName, criteria, values, replace);
+        return this.db.updateAll(collectionName, criteria, values);
     }
     /**
      * Updates a single document by UUID.
      */
-    async update(collectionName, id, data, replace = false, objectTypeName) {
+    async update(collectionName, id, data, replace = false) {
         // Ensure it returns { updated: number }
-        return this.db.update(collectionName, id, data, replace, objectTypeName);
+        return this.db.update(collectionName, id, data, replace);
     }
     /**
      * Removes (soft deletes) multiple documents based on criteria.

package/db.d.ts

@@ -74,9 +74,8 @@ export declare class K2DB {
      * @param collectionName - Name of the collection.
      * @param criteria - Update criteria.
      * @param values - Values to update or replace with.
-     * @param replace - If true, replaces the entire document (PUT), otherwise patches (PATCH).
      */
-    updateAll(collectionName: string, criteria: any, values: Partial<BaseDocument>, replace?: boolean): Promise<{
+    updateAll(collectionName: string, criteria: any, values: Partial<BaseDocument>): Promise<{
         updated: number;
     }>;
     /**
@@ -86,9 +85,8 @@ export declare class K2DB {
      * @param id - UUID string to identify the document.
      * @param data - Data to update or replace with.
      * @param replace - If true, replaces the entire document (PUT), otherwise patches (PATCH).
-     * @param objectTypeName - Optional object type name.
      */
-    update(collectionName: string, id: string, data: Partial<BaseDocument>, replace?: boolean, objectTypeName?: string): Promise<{
+    update(collectionName: string, id: string, data: Partial<BaseDocument>, replace?: boolean): Promise<{
         updated: number;
     }>;
     /**

package/db.js

@@ -263,26 +263,21 @@ class K2DB {
      * @param collectionName - Name of the collection.
      * @param criteria - Update criteria.
      * @param values - Values to update or replace with.
-     * @param replace - If true, replaces the entire document (PUT), otherwise patches (PATCH).
      */
-    async updateAll(collectionName, criteria, values, replace = false) {
-        // Return type changed to JSON object {updated: number}
+    async updateAll(collectionName, criteria, values) {
+        this.validateCollectionName(collectionName);
         const collection = await this.getCollection(collectionName);
         debug(`Updating ${collectionName} with criteria: ${JSON.stringify(criteria)}`);
         values._updated = Date.now();
-        // Exclude soft-deleted documents unless _deleted is explicitly specified in criteria
-        if (!("_deleted" in criteria)) {
-            criteria = {
-                ...criteria,
-                _deleted: { $ne: true },
-            };
-        }
-        // Determine update operation based on the replace flag
-        const updateOperation = replace ? values : { $set: values };
+        criteria = {
+            ...criteria,
+            _deleted: { $ne: true },
+        };
         try {
-            const res = await collection.updateMany(criteria, updateOperation);
-            // Return the updated count in JSON format
-            return { updated: res.modifiedCount };
+            const res = await collection.updateMany(criteria, { $set: values });
+            return {
+                updated: res.modifiedCount,
+            };
         }
         catch (err) {
             throw new k2error_1.K2Error(k2error_1.ServiceError.SYSTEM_ERROR, `Error updating ${collectionName}`, "sys_mdb_update1", this.normalizeError(err));
@@ -295,28 +290,48 @@ class K2DB {
      * @param id - UUID string to identify the document.
      * @param data - Data to update or replace with.
      * @param replace - If true, replaces the entire document (PUT), otherwise patches (PATCH).
-     * @param objectTypeName - Optional object type name.
      */
-    async update(collectionName, id, data, replace = false, objectTypeName) {
+    async update(collectionName, id, data, replace = false) {
+        this.validateCollectionName(collectionName);
         const collection = await this.getCollection(collectionName);
         data._updated = Date.now(); // Set the _updated timestamp
         try {
-            // Call updateAll with the UUID criteria and replace flag
-            const res = await this.updateAll(collectionName, { _uuid: id }, data, replace);
+            let res;
+            // If replacing the document, first get the original document
+            if (replace) {
+                // Get the original document to preserve fields starting with underscore
+                const originalDoc = await this.get(collectionName, id);
+                // Override all fields starting with underscore from the original document
+                const fieldsToPreserve = Object.keys(originalDoc).reduce((acc, key) => {
+                    if (key.startsWith("_")) {
+                        acc[key] = originalDoc[key];
+                    }
+                    return acc;
+                }, {});
+                // Merge the preserved fields into the data
+                data = { ...data, ...fieldsToPreserve };
+                data._updated = Date.now();
+                // Now replace the document with the merged data
+                res = await collection.replaceOne({ _uuid: id }, data);
+            }
+            else {
+                // If patching, just update specific fields using $set
+                res = await collection.updateOne({ _uuid: id }, { $set: data });
+            }
             // Check if exactly one document was updated
-            if (res.updated === 1) {
+            if (res.modifiedCount === 1) {
                 return { updated: 1 };
             }
             // If no document was updated, throw a NOT_FOUND error
-            if (res.updated === 0) {
+            if (res.modifiedCount === 0) {
                 throw new k2error_1.K2Error(k2error_1.ServiceError.NOT_FOUND, `Object in ${collectionName} with UUID ${id} not found`, "sys_mdb_update_not_found");
             }
-            // If more than one document was updated, throw a SYSTEM_ERROR
-            if (res.updated > 1) {
+            // If more than one document was updated (though this should never happen with a single UUID), throw a SYSTEM_ERROR
+            if (res.modifiedCount > 1) {
                 throw new k2error_1.K2Error(k2error_1.ServiceError.SYSTEM_ERROR, `Multiple objects in ${collectionName} were updated when only one was expected`, "sys_mdb_update_multiple_found");
             }
-            // Since we've handled all possible valid cases, we return undefined in case of unforeseen errors (for type safety)
-            return { updated: 0 }; // Should never reach this line, here for type safety
+            // Return updated: 0 if no documents were modified (though this is unlikely)
+            return { updated: 0 };
         }
         catch (err) {
             if (err instanceof k2error_1.K2Error) {
@@ -332,33 +347,16 @@ class K2DB {
      * @param criteria - Removal criteria.
      */
     async deleteAll(collectionName, criteria) {
-        const collection = await this.getCollection(collectionName);
-        try {
-            // Step 1: Count documents matching the original criteria (this is not strictly necessary if you only want the deleted count)
-            const foundCount = await collection.countDocuments(criteria);
-        }
-        catch (err) {
-            throw new k2error_1.K2Error(k2error_1.ServiceError.SYSTEM_ERROR, `Error updating ${collectionName}`, "sys_mdb_deleteall_count", this.normalizeError(err));
-        }
-        // Step 2: Modify criteria to exclude already deleted documents
-        const modifiedCriteria = {
-            ...criteria,
-            _deleted: { $ne: true },
-        };
-        let result;
+        this.validateCollectionName(collectionName);
         try {
-            // Perform the update to soft delete the documents
-            result = await this.updateAll(collectionName, modifiedCriteria, {
+            let result = await this.updateAll(collectionName, criteria, {
                 _deleted: true,
             });
+            return { deleted: result.updated };
         }
         catch (err) {
             throw new k2error_1.K2Error(k2error_1.ServiceError.SYSTEM_ERROR, `Error updating ${collectionName}`, "sys_mdb_deleteall_update", this.normalizeError(err));
         }
-        // Step 3: Return the number of records that were marked as deleted
-        return {
-            deleted: result.updated, // Map the updated count to 'deleted'
-        };
     }
     /**
      * Removes (soft deletes) a single document by UUID.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frogfish/k2db",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "A data handling library for K2 applications.",
   "main": "data.js",
   "types": "data.d.ts",