file: 지워지는 데이터 기준으로 파일 위치 이동

Author: opficdev

Firebase/functions/src/index.ts

@@ -33,10 +33,7 @@ import {
 } from "./fcm/schedule";
 
 import {
-    removeTodoNotificationDocuments,
-    removeCompletedTodoNotificationRecords,
-    cleanupSoftDeletedTodos,
-    cleanupUnusedTodoNotificationRecords
+    cleanupSoftDeletedTodos
 } from "./todo/cleanup";
 
 import {
@@ -61,6 +58,9 @@ import {
 } from "./notification/deletion";
 
 import {
+    removeTodoNotificationDocuments,
+    removeCompletedTodoNotificationRecords,
+    cleanupUnusedTodoNotificationRecords,
     cleanupSoftDeletedNotifications
 } from "./notification/cleanup";
 

Firebase/functions/src/notification/cleanup.ts

@@ -1,10 +1,77 @@
+import { onDocumentDeleted, onDocumentUpdated } from "firebase-functions/v2/firestore";
 import { onSchedule } from "firebase-functions/v2/scheduler";
 import * as admin from "firebase-admin";
 import * as logger from "firebase-functions/logger";
+import { toDate } from "../common/date";
 import { toError } from "../common/error";
+import { FirestorePath } from "../common/firestorePath";
 
 const LOCATION = "asia-northeast3";
 const CLEANUP_BATCH_SIZE = 200;
+const DELETE_BATCH_SIZE = 200;
+const QUERY_BATCH_SIZE = 100;
+
+// Todo 삭제 시 연결된 알림 문서와 발송 기록 문서의 동시 제거
+export const removeTodoNotificationDocuments = onDocumentDeleted({
+        maxInstances: 1,
+        document: "users/{userId}/todoLists/{todoId}",
+        region: LOCATION
+    },
+    async (event) => {
+        const userId = event.params.userId;
+        const todoId = event.params.todoId;
+
+        try {
+            await deleteByTodoId(userId, "notificationDispatches", todoId);
+            await deleteByTodoId(userId, "notifications", todoId);
+        } catch (error) {
+            logger.error(
+                "todo 삭제 후 notification 문서 정리 실패",
+                toError(error),
+                {
+                    userId,
+                    todoId,
+                    collections: ["notificationDispatches", "notifications"]
+                }
+            );
+        }
+    }
+);
+
+// 지난 마감일 Todo 완료 시 재발송 방지 기록 정리
+export const removeCompletedTodoNotificationRecords = onDocumentUpdated({
+        maxInstances: 1,
+        document: "users/{userId}/todoLists/{todoId}",
+        region: LOCATION
+    },
+    async (event) => {
+        const beforeData = event.data?.before.data();
+        const afterData = event.data?.after.data();
+        const userId = event.params.userId;
+        const todoId = event.params.todoId;
+
+        if (!beforeData || !afterData) { return; }
+        if (beforeData.isCompleted === true || afterData.isCompleted !== true) { return; }
+
+        const dueDate = toDate(afterData.dueDate);
+
+        if (!dueDate || Date.now() <= dueDate.getTime()) { return; }
+
+        try {
+            await deleteByTodoId(userId, "notificationDispatches", todoId);
+        } catch (error) {
+            logger.error(
+                "완료된 todo의 notification record 정리 실패",
+                toError(error),
+                {
+                    userId,
+                    todoId,
+                    collection: "notificationDispatches"
+                }
+            );
+        }
+    }
+);
 
 export const cleanupSoftDeletedNotifications = onSchedule({
         maxInstances: 1,
@@ -44,3 +111,122 @@ export const cleanupSoftDeletedNotifications = onSchedule({
         }
     }
 );
+
+// 사용되지 않는 알림 발송 기록의 주기적 정리
+export const cleanupUnusedTodoNotificationRecords = onSchedule({
+        maxInstances: 1,
+        region: LOCATION,
+        schedule: "0 * * * *",
+        timeZone: "UTC"
+    },
+    async () => {
+        try {
+            await cleanupDispatchesByTodoQuery((lastDocument) => {
+                let query = admin.firestore()
+                    .collectionGroup("todoLists")
+                    .where("isCompleted", "==", true)
+                    .where("dueDate", "<", admin.firestore.Timestamp.now())
+                    .orderBy("dueDate")
+                    .limit(QUERY_BATCH_SIZE);
+
+                if (lastDocument) {
+                    query = query.startAfter(lastDocument);
+                }
+
+                return query;
+            });
+        } catch (error) {
+            logger.error(
+                "지난 마감일의 완료된 todo notification record 정리 실패",
+                toError(error),
+                {
+                    collectionGroup: "todoLists",
+                    filter: "isCompleted == true && dueDate < now",
+                    orderBy: "dueDate",
+                    queryBatchSize: QUERY_BATCH_SIZE
+                }
+            );
+        }
+
+        try {
+            await cleanupDispatchesByTodoQuery((lastDocument) => {
+                let query = admin.firestore()
+                    .collectionGroup("todoLists")
+                    .where("dueDate", "==", null)
+                    .orderBy(admin.firestore.FieldPath.documentId())
+                    .limit(QUERY_BATCH_SIZE);
+
+                if (lastDocument) {
+                    query = query.startAfter(lastDocument);
+                }
+
+                return query;
+            });
+        } catch (error) {
+            logger.error(
+                "마감일이 없는 todo notification record 정리 실패",
+                toError(error),
+                {
+                    collectionGroup: "todoLists",
+                    filter: "dueDate == null",
+                    orderBy: "__name__",
+                    queryBatchSize: QUERY_BATCH_SIZE
+                }
+            );
+        }
+    }
+);
+
+// Todo 조회 쿼리를 순회하며 연결된 알림 발송 기록을 정리
+async function cleanupDispatchesByTodoQuery(
+    makeQuery: (
+        lastDocument?:
+            FirebaseFirestore.QueryDocumentSnapshot<FirebaseFirestore.DocumentData>
+    ) => FirebaseFirestore.Query<FirebaseFirestore.DocumentData>
+): Promise<void> {
+    let lastDocument:
+        FirebaseFirestore.QueryDocumentSnapshot<FirebaseFirestore.DocumentData> | undefined;
+
+    while (true) {
+        const snapshot = await makeQuery(lastDocument).get();
+        if (snapshot.empty) { return; }
+
+        for (const todoDoc of snapshot.docs) {
+            const userId = todoDoc.ref.parent.parent?.id;
+            if (!userId) { continue; }
+
+            await deleteByTodoId(userId, "notificationDispatches", todoDoc.id);
+        }
+
+        if (snapshot.size < QUERY_BATCH_SIZE) { return; }
+        lastDocument = snapshot.docs[snapshot.docs.length - 1];
+    }
+}
+
+// 특정 Todo 연결 문서의 배치 단위 전체 삭제
+async function deleteByTodoId(
+    userId: string,
+    collectionName: "notificationDispatches" | "notifications",
+    todoId: string
+): Promise<void> {
+    while (true) {
+        const collectionPath = collectionName === "notificationDispatches" ?
+            FirestorePath.notificationDispatches(userId) :
+            FirestorePath.notifications(userId);
+        const snapshot = await admin.firestore()
+            .collection(collectionPath)
+            .where("todoId", "==", todoId)
+            .limit(DELETE_BATCH_SIZE)
+            .get();
+
+        if (snapshot.empty) { return; }
+
+        const batch = admin.firestore().batch();
+        snapshot.docs.forEach((document) => {
+            batch.delete(document.ref);
+        });
+        await batch.commit();
+
+        if (snapshot.size < DELETE_BATCH_SIZE) { return; }
+    }
+}