feat: add patch to mongo

Author: jkoenig134

packages/mongo/package.json

@@ -29,6 +29,7 @@
     },
     "dependencies": {
         "@js-soft/docdb-access-abstractions": "1.1.0",
+        "fast-json-patch": "^3.1.1",
         "mongodb": "6.17.0"
     },
     "publishConfig": {

packages/mongo/src/MongoDbCollection.ts

@@ -4,6 +4,7 @@ import {
     DatabaseType,
     IDatabaseCollection
 } from "@js-soft/docdb-access-abstractions";
+import jsonpatch from "fast-json-patch";
 import { Collection } from "mongodb";
 import { removeContainsInQuery } from "./queryUtils";
 
@@ -34,16 +35,59 @@ export class MongoDbCollection implements IDatabaseCollection {
     }
 
     public async update(oldDoc: any, data: any): Promise<any> {
-        let doc: any;
+        if (typeof data.toJSON === "function") data = data.toJSON();
 
+        const updateResult = await this.collection.replaceOne(oldDoc, data);
+        if (updateResult.modifiedCount < 1) throw new Error("Document not found for updating");
+
+        return data;
+    }
+
+    public async patch(oldDoc: any, data: any): Promise<any> {
         if (typeof data.toJSON === "function") {
-            doc = data.toJSON();
-        } else {
-            doc = data;
+            data = data.toJSON();
         }
 
-        await this.collection.replaceOne(oldDoc, doc);
-        return data;
+        const patch = jsonpatch.compare(oldDoc, data);
+
+        const patchMappedToMongoDbOps = patch
+            .filter((v) => v.path !== "/_id")
+            .map((op) => {
+                const path = op.path.startsWith("/")
+                    ? op.path.substring(1).replaceAll("/", ".")
+                    : op.path.replaceAll("/", ".");
+
+                switch (op.op) {
+                    case "add":
+                    case "replace":
+                        return { $set: { [path]: op.value } };
+                    case "remove":
+                        return { $unset: { [path]: "" } };
+                    case "move":
+                        // TODO: hard to implement
+                        // return { $set: { [op.path]: oldDoc[op.from] }, $unset: { [op.from]: "" } };
+                        throw new Error("Move operation is not supported in MongoDB");
+                    case "copy":
+                        // TODO: hard to implement
+                        // return { $set: { [op.path]: oldDoc[op.from] } };
+                        throw new Error("Move operation is not supported in MongoDB");
+                    case "test":
+                    // Test operations are not supported in MongoDB, so we ignore them
+                    case "_get":
+                    default:
+                        throw new Error(`Unsupported operation: ${op.op}`);
+                }
+            });
+
+        const updated = await this.collection.findOneAndUpdate({ id: oldDoc.id }, patchMappedToMongoDbOps, {
+            returnDocument: "after"
+        });
+
+        if (!updated) {
+            throw new Error("Document not found for patching");
+        }
+
+        return updated;
     }
 
     public async delete(query: any): Promise<boolean> {

packages/mongo/test/DatabaseCollection.test.ts

@@ -241,4 +241,42 @@ describe("DatabaseCollection", () => {
 
         await expect(db.create({ id: "uniqueValue" })).rejects.toThrow(/[Dd]uplicate key/);
     });
+
+    describe("patch vs update", () => {
+        test("update is not working properly", async () => {
+            const db = await getRandomCollection();
+
+            const entry = { id: "test", name: "test" };
+            const createdEntry = await db.create(entry);
+
+            // this will completely replaced
+            await db.update(createdEntry, { id: "test", name: "updated" });
+
+            // this will not replace the above b/c it's not even found
+            await expect(
+                db.update(createdEntry, { id: "test", name: "test", anotherField: "newField" })
+            ).rejects.toThrow("Document not found for updating");
+
+            const queriedEntry = await db.findOne({ id: "test" });
+            expect(queriedEntry.name).toBe("updated");
+            expect(queriedEntry.anotherField).toBeUndefined();
+        });
+
+        test("patch is better", async () => {
+            const db = await getRandomCollection();
+
+            const entry = { id: "test", name: "test" };
+            const createdEntry = await db.create(entry);
+
+            // this changes name
+            await db.patch(createdEntry, { id: "test", name: "updated" });
+
+            // this only adds another field
+            await db.patch(createdEntry, { id: "test", name: "test", anotherField: "newField" });
+
+            const queriedEntry = await db.findOne({ id: "test" });
+            expect(queriedEntry.name).toBe("updated");
+            expect(queriedEntry.anotherField).toBe("newField");
+        });
+    });
 });