@frogfish/k2db 1.0.7 → 1.0.9

package/data.d.ts

@@ -33,20 +33,26 @@ export declare class K2Data {
     /**
      * Updates multiple documents based on criteria.
      */
-    updateAll(collectionName: string, criteria: any, values: Partial<BaseDocument>, replace?: boolean): Promise<any>;
+    updateAll(collectionName: string, criteria: any, values: Partial<BaseDocument>, replace?: boolean): Promise<{
+        updated: number;
+    }>;
     /**
      * Updates a single document by UUID.
      */
-    update(collectionName: string, id: string, data: Partial<BaseDocument>, replace?: boolean, objectTypeName?: string): Promise<any>;
+    update(collectionName: string, id: string, data: Partial<BaseDocument>, replace?: boolean, objectTypeName?: string): Promise<{
+        updated: number;
+    }>;
     /**
      * Removes (soft deletes) multiple documents based on criteria.
      */
-    deleteAll(collectionName: string, criteria: any): Promise<any>;
+    deleteAll(collectionName: string, criteria: any): Promise<{
+        deleted: number;
+    }>;
     /**
      * Removes (soft deletes) a single document by UUID.
      */
     delete(collectionName: string, id: string): Promise<{
-        id: string;
+        deleted: number;
     }>;
     /**
      * Permanently deletes a document that has been soft-deleted.

package/data.js

@@ -1,5 +1,4 @@
 "use strict";
-// src/Data.ts
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.K2Data = void 0;
 class K2Data {
@@ -45,19 +44,22 @@ class K2Data {
     /**
      * Updates multiple documents based on criteria.
      */
-    async updateAll(collectionName, criteria, values, replace) {
+    async updateAll(collectionName, criteria, values, replace = false) {
+        // Ensure it returns { updated: number }
         return this.db.updateAll(collectionName, criteria, values, replace);
     }
     /**
      * Updates a single document by UUID.
      */
-    async update(collectionName, id, data, replace, objectTypeName) {
+    async update(collectionName, id, data, replace = false, objectTypeName) {
+        // Ensure it returns { updated: number }
         return this.db.update(collectionName, id, data, replace, objectTypeName);
     }
     /**
      * Removes (soft deletes) multiple documents based on criteria.
      */
     async deleteAll(collectionName, criteria) {
+        // Ensure it returns { deleted: number }
         return this.db.deleteAll(collectionName, criteria);
     }
     /**

package/db.d.ts

@@ -76,7 +76,9 @@ export declare class K2DB {
      * @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<any>;
+    updateAll(collectionName: string, criteria: any, values: Partial<BaseDocument>, replace?: boolean): Promise<{
+        updated: number;
+    }>;
     /**
      * Updates a single document by UUID.
      * Can either replace the document or patch it.
@@ -86,20 +88,24 @@ export declare class K2DB {
      * @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<any>;
+    update(collectionName: string, id: string, data: Partial<BaseDocument>, replace?: boolean, objectTypeName?: string): Promise<{
+        updated: number;
+    }>;
     /**
      * Removes (soft deletes) multiple documents based on criteria.
      * @param collectionName - Name of the collection.
      * @param criteria - Removal criteria.
      */
-    deleteAll(collectionName: string, criteria: any): Promise<any>;
+    deleteAll(collectionName: string, criteria: any): Promise<{
+        deleted: number;
+    }>;
     /**
      * Removes (soft deletes) a single document by UUID.
      * @param collectionName - Name of the collection.
      * @param id - UUID of the document.
      */
     delete(collectionName: string, id: string): Promise<{
-        id: string;
+        deleted: number;
     }>;
     /**
      * Permanently deletes a document that has been soft-deleted.

package/db.js

@@ -76,7 +76,10 @@ class K2DB {
         }
     }
     async get(collectionName, uuid) {
-        const res = await this.findOne(collectionName, { _uuid: uuid });
+        const res = await this.findOne(collectionName, {
+            _uuid: uuid,
+            _deleted: { $ne: true },
+        });
         if (!res) {
             throw new k2error_1.K2Error(k2error_1.ServiceError.SYSTEM_ERROR, "Error getting the document with provided identity", "sys_mdb_get");
         }
@@ -92,6 +95,8 @@ class K2DB {
     async findOne(collectionName, criteria, fields) {
         const collection = await this.getCollection(collectionName);
         const projection = {};
+        // Ensure to include the _deleted filter in criteria
+        criteria._deleted = { $ne: true };
         if (fields && fields.length > 0) {
             fields.forEach((field) => {
                 projection[field] = 1;
@@ -266,6 +271,7 @@ class K2DB {
      * @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}
         const collection = await this.getCollection(collectionName);
         debug(`Updating ${collectionName} with criteria: ${JSON.stringify(criteria)}`);
         values._updated = Date.now();
@@ -280,11 +286,8 @@ class K2DB {
         const updateOperation = replace ? values : { $set: values };
         try {
             const res = await collection.updateMany(criteria, updateOperation);
-            return {
-                found: res.matchedCount,
-                modified: res.modifiedCount,
-                updated: res.acknowledged,
-            };
+            // Return the updated count in JSON format
+            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));
@@ -301,22 +304,31 @@ class K2DB {
      */
     async update(collectionName, id, data, replace = false, objectTypeName) {
         const collection = await this.getCollection(collectionName);
-        data._updated = Date.now();
+        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);
-            if (res.modified === 1) {
-                return { id: id };
+            // Check if exactly one document was updated
+            if (res.updated === 1) {
+                return { updated: 1 };
             }
-            if (res.modified === 0) {
-                throw new k2error_1.K2Error(k2error_1.ServiceError.NOT_FOUND, `Object in ${collectionName} not found`, "sys_mdb_update2");
+            // If no document was updated, throw a NOT_FOUND error
+            if (res.updated === 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) {
+                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
         }
         catch (err) {
             if (err instanceof k2error_1.K2Error) {
                 throw err;
             }
-            throw new k2error_1.K2Error(k2error_1.ServiceError.SYSTEM_ERROR, `Error updating ${collectionName}`, "sys_mdb_update1", this.normalizeError(err));
+            // Catch any other unhandled errors and throw a system error
+            throw new k2error_1.K2Error(k2error_1.ServiceError.SYSTEM_ERROR, `Error updating ${collectionName}`, "sys_mdb_update_error", this.normalizeError(err));
         }
     }
     /**
@@ -326,10 +338,9 @@ class K2DB {
      */
     async deleteAll(collectionName, criteria) {
         const collection = await this.getCollection(collectionName);
-        let foundCount;
         try {
-            // Step 1: Count documents matching the original criteria
-            foundCount = await collection.countDocuments(criteria);
+            // 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));
@@ -341,7 +352,7 @@ class K2DB {
         };
         let result;
         try {
-            // Perform the update
+            // Perform the update to soft delete the documents
             result = await this.updateAll(collectionName, modifiedCriteria, {
                 _deleted: true,
             });
@@ -349,10 +360,9 @@ class K2DB {
         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 result, adjusting the 'found' count
+        // Step 3: Return the number of records that were marked as deleted
         return {
-            ...result,
-            found: foundCount, // Use the original count here
+            deleted: result.updated, // Map the updated count to 'deleted'
         };
     }
     /**
@@ -362,8 +372,21 @@ class K2DB {
      */
     async delete(collectionName, id) {
         try {
-            await this.deleteAll(collectionName, { _uuid: id });
-            return { id };
+            // Call deleteAll to soft delete the document by UUID
+            const result = await this.deleteAll(collectionName, { _uuid: id });
+            // Check the result of the deleteAll operation
+            if (result.deleted === 1) {
+                // Successfully deleted one document
+                return { deleted: 1 };
+            }
+            else if (result.deleted === 0) {
+                // No document was found to delete
+                throw new k2error_1.K2Error(k2error_1.ServiceError.NOT_FOUND, "Document not found", "sys_mdb_remove_not_found");
+            }
+            else {
+                // More than one document was deleted, which is unexpected
+                throw new k2error_1.K2Error(k2error_1.ServiceError.SYSTEM_ERROR, "Multiple documents deleted when only one was expected", "sys_mdb_remove_multiple_deleted");
+            }
         }
         catch (err) {
             throw new k2error_1.K2Error(k2error_1.ServiceError.SYSTEM_ERROR, "Error removing object from collection", "sys_mdb_remove_upd", this.normalizeError(err));
@@ -420,6 +443,8 @@ class K2DB {
     async count(collectionName, criteria) {
         const collection = await this.getCollection(collectionName);
         try {
+            // Ensure to include the _deleted filter in criteria
+            criteria._deleted = { $ne: true };
             const cnt = await collection.countDocuments(criteria);
             return { count: cnt };
         }

package/package.json

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