fix(delete-user-data): recursive delete searched docs if enabled (#2073)

* fix(delete-user-data): recursive delete searched docs if enabled

* chore(delete-user-data): move test to __tests__

Author: cabljac

delete-user-data/functions/__tests__/handleDelete.test.ts

@@ -0,0 +1,94 @@
+import { handleDeletion } from "../src";
+import * as admin from "firebase-admin"; // Import Firebase admin to mock Firestore
+import firebaseFunctionsTest from "firebase-functions-test";
+import { search } from "../src/search";
+import { Message } from "@google-cloud/pubsub";
+
+const testEnv = firebaseFunctionsTest();
+const { wrap } = testEnv;
+
+jest.mock("../src/config", () => ({
+  location: "us-central1",
+  firestorePaths: "test",
+  firestoreDeleteMode: "recursive",
+  rtdbPaths: undefined,
+  storagePaths: undefined,
+  enableSearch: true,
+  storageBucketDefault: "test",
+  selectedDatabaseInstance: "test",
+  selectedDatabaseLocation: "us-central1",
+  searchFields: "uid",
+  searchFunction: undefined,
+  discoveryTopic: "ext-test-discovery",
+  deletionTopic: "ext-test-deletion",
+  searchDepth: 3,
+}));
+const wrapped = wrap(handleDeletion);
+const wrappedHandleDelete = ({
+  uid,
+  paths,
+}: {
+  uid: string;
+  paths: string[];
+}) => {
+  //@ts-ignore
+  return wrapped({
+    data: Buffer.from(JSON.stringify({ uid, paths })).toString("base64"),
+  });
+};
+
+const db = admin.firestore();
+
+describe("handleDelete", () => {
+  test("should delete valid paths correctly", async () => {
+    const paths = ["valid/path1", "valid/path2"];
+
+    for (const path of paths) {
+      await db.doc(path).set({ uid: "testUid" });
+    }
+    await wrappedHandleDelete({ uid: "testUid", paths });
+
+    const checkExists = await Promise.all(
+      paths.map(async (path) => {
+        const doc = await db.doc(path).get();
+        return doc.exists;
+      })
+    );
+    for (const exists of checkExists) {
+      expect(exists).toBe(false);
+    }
+  });
+
+  test("should delete subcollections of matching docs", async () => {
+    const paths = ["valid/path1", "valid/path2"];
+
+    for (const path of paths) {
+      await db.doc(path).set({ uid: "testUid" });
+      await db.doc(`${path}/subcollection/doc`).set({ foo: "bar" });
+    }
+
+    await wrappedHandleDelete({ uid: "testUid", paths });
+
+    const checkExists = await Promise.all(
+      paths.map(async (path) => {
+        const doc = await db.doc(path).get();
+        return doc.exists;
+      })
+    );
+
+    for (const exists of checkExists) {
+      expect(exists).toBe(false);
+    }
+
+    const subcollectionDocs = await Promise.all(
+      paths.map(async (path) => {
+        const snapshot = await db.doc(`${path}/subcollection/doc`).get();
+        return snapshot.exists;
+      })
+    );
+
+    for (const exists of subcollectionDocs) {
+      expect(exists).toBe(false);
+    }
+  });
+});

delete-user-data/functions/__tests__/recursiveDelete.test.ts

@@ -0,0 +1,59 @@
+// Import your function and any necessary Firebase modules
+import { recursiveDelete } from "../src/recursiveDelete"; // Update with your actual file path
+import * as admin from "firebase-admin";
+
+const bulkWriterMock = () => ({
+  onWriteError: jest.fn(),
+  close: jest.fn(() => Promise.resolve()),
+});
+// Mock admin and firestore
+
+admin.initializeApp();
+
+describe("recursiveDelete", () => {
+  // Common setup
+  const db = admin.firestore();
+
+  test("successfully deletes a document reference", async () => {
+    const ref = "documents/doc1";
+    db.doc(ref).create({
+      foo: "bar",
+    });
+
+    await recursiveDelete(ref);
+
+    const doc = db.doc(ref);
+    await doc.get().then((doc) => {
+      expect(doc.exists).toBe(false);
+    });
+  });
+
+  test("successfully deletes a collection reference", async () => {
+    const ref = "documents/doc1/collection1";
+    db.collection(ref).add({
+      foo: "bar",
+    });
+
+    await recursiveDelete(ref);
+
+    const collection = db.collection(ref);
+    await collection.get().then((collection) => {
+      expect(collection.docs.length).toBe(0);
+    });
+  });
+
+  test("successfully deletes a document with a subcollection", async () => {
+    const parentRef = "documents/doc1";
+    const ref = "documents/doc1/collection1/doc2/collection2";
+    db.collection(ref).add({
+      foo: "bar",
+    });
+
+    await recursiveDelete(parentRef);
+
+    const collection = db.collection(ref);
+    await collection.get().then((collection) => {
+      expect(collection.docs.length).toBe(0);
+    });
+  });
+});

delete-user-data/functions/package-lock.json

@@ -10,9 +10,10 @@
     "compile": "tsc",
     "local:emulator": "cd ../../_emulator && firebase emulators:start -P demo-test",
     "test": "cd ../../_emulator && firebase emulators:exec jest -P demo-test",
-    "test:local": "concurrently \"npm run local:emulator\" \"jest\"",
+    "test:local": "cd ../../_emulator && firebase emulators:exec \"CI_TEST=true jest --detectOpenHandles --verbose --forceExit --testMatch **/delete-user-data/**/*.test.ts\"",
     "test:watch": "concurrently \"npm run local:emulator\" \"jest --watch\"",
-    "generate-readme": "firebase ext:info .. --markdown > ../README.md"
+    "generate-readme": "firebase ext:info .. --markdown > ../README.md",
+    "test:emulator-running": "jest"
   },
   "author": "Lauren Long <[email protected]>",
   "license": "Apache-2.0",
@@ -33,13 +34,14 @@
   },
   "private": true,
   "devDependencies": {
+    "@types/jest": "29.5.0",
     "@types/lodash.chunk": "^4.2.7",
     "@types/node-fetch": "^2.6.2",
     "concurrency": "^0.1.4",
     "dotenv": "^16.0.2",
-    "wait-port": "^0.2.9",
-    "@types/jest": "29.5.0",
+    "firebase-functions-test": "^3.2.0",
     "jest": "29.5.0",
-    "ts-jest": "29.1.2"
+    "ts-jest": "29.1.2",
+    "wait-port": "^0.2.9"
   }
 }

delete-user-data/functions/package.json

@@ -81,8 +81,11 @@ export const handleDeletion = functions.pubsub
           invalidPaths.push(path);
           continue;
         }
-
-        batch.delete(docRef);
+        if (config.firestoreDeleteMode === "recursive") {
+          await recursiveDelete(path);
+        } else {
+          batch.delete(docRef);
+        }
       }
 
       batchArray.push(batch);
@@ -155,7 +158,7 @@ export const handleSearch = functions.pubsub
           if (reference.id === uid) {
             pathsToDelete.push(reference.path);
           }
-          // If the user has search fields, all the document to the list of documents to search.
+          // If the user has search fields, add the document to the list of documents to search.
           else if (config.searchFields) {
             documentReferencesToSearch.push(reference);
           }

delete-user-data/functions/src/index.ts

@@ -2,7 +2,7 @@ import * as admin from "firebase-admin";
 
 const MAX_RETRY_ATTEMPTS = 3;
 
-export const recursiveDelete = async (ref: string) => {
+export const recursiveDelete = async (path: string) => {
   const db = admin.firestore();
   // Recursively delete a reference and log the references of failures.
   const bulkWriter = db.bulkWriter();
@@ -16,9 +16,9 @@ export const recursiveDelete = async (ref: string) => {
     }
   });
 
-  const isDocument = ref.split("/").length % 2 === 0;
+  const isDocument = path.split("/").length % 2 === 0;
 
-  const reference = isDocument ? db.doc(ref) : db.collection(ref);
+  const reference = isDocument ? db.doc(path) : db.collection(path);
 
   await db.recursiveDelete(reference, bulkWriter);
 };

delete-user-data/functions/src/recursiveDelete.ts

@@ -26,15 +26,15 @@
     "url": ""
   },
   "devDependencies": {
+    "@types/jest": "29.5.0",
     "codecov": "^3.8.1",
-    "husky": "^7.0.4",
-    "lint-staged": "^12.4.0",
     "concurrently": "^7.2.1",
-    "@types/jest": "29.5.0",
-    "jest": "29.5.0",
-    "ts-jest": "29.1.2",
+    "husky": "^7.0.4",
+    "jest": "^29.7.0",
     "lerna": "^3.4.3",
+    "lint-staged": "^12.4.0",
     "prettier": "2.7.1",
+    "ts-jest": "29.1.2",
     "typescript": "^4.8.4"
   },
   "lint-staged": {