refactor: use jsonPatchToMongoDbOps script

Author: jkoenig134

packages/mongo/src/MongoDbCollection.ts

@@ -6,6 +6,7 @@ import {
 } from "@js-soft/docdb-access-abstractions";
 import jsonpatch from "fast-json-patch";
 import { Collection } from "mongodb";
+import { jsonPatchToMongoDbOps } from "./jsonPatchToMongoDbOps";
 import { removeContainsInQuery } from "./queryUtils";
 
 export class MongoDbCollection implements IDatabaseCollection {
@@ -49,39 +50,16 @@ export class MongoDbCollection implements IDatabaseCollection {
         }
 
         const patch = jsonpatch.compare(oldDoc, data);
+        const filter = { id: oldDoc.id };
 
-        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"
-        });
+        const operations = await jsonPatchToMongoDbOps(
+            patch.filter((v) => v.path !== "/_id"),
+            filter,
+            this.collection
+        );
+        await this.collection.bulkWrite(operations);
+
+        const updated = await this.collection.findOne({ id: oldDoc.id });
 
         if (!updated) {
             throw new Error("Document not found for patching");

packages/mongo/src/jsonPatchToMongoDbOps.ts

@@ -0,0 +1,119 @@
+/**
+ * credit to https://github.com/fathomas/json-patch-to-mongodb-ops/tree/main
+ */
+
+import { Operation, validate } from "fast-json-patch";
+import { PatchError } from "fast-json-patch/module/helpers";
+import { AnyBulkWriteOperation, Collection } from "mongodb";
+
+export const jsonPatchPathToDot = (path: string): string =>
+    path.replace(/^\//, "").replace(/\//g, ".").replace(/~1/g, "/").replace(/~0/g, "~");
+
+function getTrailingPos(path: string): number {
+    const parts = path.split(".");
+    const pathTail = parts.slice(-1)[0];
+    return parts.length > 1 ? (pathTail === "-" ? -1 : parseInt(pathTail, 10)) : NaN;
+}
+
+function $remove(path: any) {
+    const result: any[] = [];
+    const trailingPos = getTrailingPos(path);
+    result.push({ $unset: { [path]: 1 } });
+    if (!Number.isNaN(trailingPos)) {
+        const pathHead = path.split(".").slice(0, -1).join(".");
+        result.push({ $pull: { [pathHead]: null } });
+    }
+    return result;
+}
+
+function $add(path: any, value) {
+    const trailingPos = getTrailingPos(path);
+    if (Number.isNaN(trailingPos)) {
+        return { $set: { [path]: value } };
+    }
+    const pathHead = path.split(".").slice(0, -1).join(".");
+    return {
+        $push: {
+            [pathHead]: trailingPos >= 0 ? { $each: [value], $position: trailingPos } : value
+        }
+    };
+}
+
+export async function jsonPatchToMongoDbOps(
+    patch: Operation[],
+    targetFilter: Record<string, any>,
+    collection: Collection
+): Promise<AnyBulkWriteOperation<{}>[]> {
+    const error = validate(patch) as PatchError | undefined;
+    if (error) throw error;
+
+    return (
+        await Promise.all(
+            patch.map(async (operation) => {
+                const path = jsonPatchPathToDot(operation.path);
+                if (!path || path.endsWith(".")) {
+                    throw new Error("Invalid update path.");
+                }
+
+                switch (operation.op) {
+                    case "add": {
+                        return $add(path, operation.value);
+                    }
+                    case "remove": {
+                        return $remove(path);
+                    }
+                    case "replace": {
+                        return { $set: { [path]: operation.value } };
+                    }
+                    case "copy":
+                    case "move": {
+                        const from = jsonPatchPathToDot(operation.from);
+                        const fromParts = from.split(".");
+                        const targetIndex = fromParts[1] && /^\d+$/.test(fromParts[1]) ? parseInt(fromParts[1]) : NaN;
+
+                        const currDoc = await collection.findOne(targetFilter, {
+                            // Reduce memory usage and speed up query.
+                            projection: {
+                                // eslint-disable-next-line @typescript-eslint/naming-convention
+                                _id: 0,
+                                ...(Number.isNaN(targetIndex)
+                                    ? {
+                                          [fromParts[0]]: 1
+                                      }
+                                    : { [fromParts[0]]: { $slice: [targetIndex, 1] } })
+                            }
+                        });
+
+                        let segmentsToWalk;
+                        let startPoint;
+                        if (Number.isNaN(targetIndex)) {
+                            segmentsToWalk = fromParts;
+                            startPoint = currDoc;
+                        } else {
+                            segmentsToWalk = fromParts.slice(2);
+                            startPoint = currDoc![fromParts[0]][0];
+                        }
+
+                        const valueToTransfer = segmentsToWalk.reduce((curr, propName) => curr[propName], startPoint);
+                        if (typeof valueToTransfer === "undefined") {
+                            throw new Error("Can't move undefined value!");
+                        }
+
+                        const addOp = $add(path, valueToTransfer);
+                        return operation.op === "copy" ? addOp : [...$remove(from), addOp];
+                    }
+                    case "test": {
+                        return undefined;
+                    }
+                    case "_get":
+                    default: {
+                        throw new Error(`Unsupported Operation! op = ${operation.op}`);
+                    }
+                }
+            })
+        )
+    )
+        .flat()
+        .filter((update) => update)
+        .map((update) => ({ updateOne: { update, filter: targetFilter } }));
+}