@dereekb/firebase-server 11.0.21 → 11.1.1

package/model/src/lib/notification/notification.action.server.js

@@ -0,0 +1,1049 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupSentNotificationsFactory = exports.sendQueuedNotificationsFactory = exports.sendNotificationFactory = exports.NOTIFICATION_BOX_NOT_INITIALIZED_DELAY_MINUTES = exports.NOTIFICATION_MAX_SEND_ATTEMPTS = exports.KNOWN_BUT_UNCONFIGURED_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS = exports.KNOWN_BUT_UNCONFIGURED_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY = exports.UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS = exports.UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY = exports.updateNotificationBoxRecipientFactory = exports.updateNotificationBoxFactory = exports.createNotificationBoxFactory = exports.createNotificationBoxInTransactionFactory = exports.updateNotificationSummaryFactory = exports.createNotificationSummaryFactory = exports.resyncAllNotificationUsersFactory = exports.resyncNotificationUserFactory = exports.updateNotificationUserFactory = exports.createNotificationUserFactory = exports.notificationServerActions = exports.NotificationServerActions = exports.NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN = exports.BASE_NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN = void 0;
+const date_1 = require("@dereekb/date");
+const firebase_1 = require("@dereekb/firebase");
+const firebase_server_1 = require("@dereekb/firebase-server");
+const util_1 = require("@dereekb/util");
+const date_fns_1 = require("date-fns");
+const notification_error_1 = require("./notification.error");
+const notification_util_1 = require("./notification.util");
+/**
+ * Injection token for the BaseNotificationServerActionsContext
+ */
+exports.BASE_NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN = 'BASE_NOTIFICATION_SERVER_ACTION_CONTEXT';
+/**
+ * Injection token for the NotificationServerActionsContext
+ */
+exports.NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN = 'NOTIFICATION_SERVER_ACTION_CONTEXT';
+class NotificationServerActions {
+}
+exports.NotificationServerActions = NotificationServerActions;
+function notificationServerActions(context) {
+    return {
+        createNotificationUser: createNotificationUserFactory(context),
+        updateNotificationUser: updateNotificationUserFactory(context),
+        resyncNotificationUser: resyncNotificationUserFactory(context),
+        resyncAllNotificationUsers: resyncAllNotificationUsersFactory(context),
+        createNotificationSummary: createNotificationSummaryFactory(context),
+        updateNotificationSummary: updateNotificationSummaryFactory(context),
+        createNotificationBox: createNotificationBoxFactory(context),
+        updateNotificationBox: updateNotificationBoxFactory(context),
+        updateNotificationBoxRecipient: updateNotificationBoxRecipientFactory(context),
+        sendNotification: sendNotificationFactory(context),
+        sendQueuedNotifications: sendQueuedNotificationsFactory(context),
+        cleanupSentNotifications: cleanupSentNotificationsFactory(context)
+    };
+}
+exports.notificationServerActions = notificationServerActions;
+// MARK: Actions
+function createNotificationUserFactory(context) {
+    const { firebaseServerActionTransformFunctionFactory, notificationUserCollection, authService } = context;
+    return firebaseServerActionTransformFunctionFactory(firebase_1.CreateNotificationUserParams, async (params) => {
+        const { uid } = params;
+        return async () => {
+            // assert they exist in the auth system
+            const userContext = authService.userContext(uid);
+            const userExistsInAuth = await userContext.exists();
+            if (!userExistsInAuth) {
+                throw (0, notification_error_1.notificationUserInvalidUidForCreateError)(uid);
+            }
+            const notificationUserDocument = notificationUserCollection.documentAccessor().loadDocumentForId(uid);
+            const newUserTemplate = {
+                uid,
+                bc: [],
+                b: [],
+                dc: {
+                    c: {}
+                },
+                gc: {
+                    c: {}
+                }
+            };
+            await notificationUserDocument.create(newUserTemplate);
+            return notificationUserDocument;
+        };
+    });
+}
+exports.createNotificationUserFactory = createNotificationUserFactory;
+function updateNotificationUserFactory(context) {
+    const { firestoreContext, firebaseServerActionTransformFunctionFactory, notificationUserCollection, appNotificationTemplateTypeInfoRecordService } = context;
+    return firebaseServerActionTransformFunctionFactory(firebase_1.UpdateNotificationUserParams, async (params) => {
+        const { gc: inputGc, dc: inputDc, bc: inputBc } = params;
+        return async (notificationUserDocument) => {
+            await firestoreContext.runTransaction(async (transaction) => {
+                const notificationUserDocumentInTransaction = notificationUserCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(notificationUserDocument);
+                const notificationUser = await (0, firebase_server_1.assertSnapshotData)(notificationUserDocumentInTransaction);
+                const updateTemplate = {};
+                const allKnownNotificationTypes = appNotificationTemplateTypeInfoRecordService.getAllKnownTemplateTypes();
+                if (inputDc != null) {
+                    updateTemplate.dc = (0, firebase_1.updateNotificationUserDefaultNotificationBoxRecipientConfig)(notificationUser.dc, inputDc, allKnownNotificationTypes);
+                }
+                if (inputGc != null) {
+                    const nextGc = (0, firebase_1.updateNotificationUserDefaultNotificationBoxRecipientConfig)(notificationUser.gc, inputGc, allKnownNotificationTypes);
+                    if (!(0, util_1.areEqualPOJOValues)(notificationUser.gc, nextGc)) {
+                        updateTemplate.gc = nextGc;
+                        // iterate and update any box config that has the effective recipient change
+                        updateTemplate.bc = notificationUser.bc.map((currentConfig) => {
+                            // check item isn't already marked for sync or marked as removed
+                            if (currentConfig.ns === true || currentConfig.rm === true) {
+                                return currentConfig;
+                            }
+                            const currentEffectiveRecipient = (0, firebase_1.effectiveNotificationBoxRecipientConfig)({
+                                uid: notificationUser.uid,
+                                appNotificationTemplateTypeInfoRecordService,
+                                gc: notificationUser.gc,
+                                boxConfig: currentConfig
+                            });
+                            const nextEffectiveRecipient = (0, firebase_1.effectiveNotificationBoxRecipientConfig)({
+                                uid: notificationUser.uid,
+                                appNotificationTemplateTypeInfoRecordService,
+                                gc: nextGc,
+                                boxConfig: currentConfig
+                            });
+                            const effectiveConfigChanged = !(0, util_1.areEqualPOJOValues)(currentEffectiveRecipient, nextEffectiveRecipient);
+                            return effectiveConfigChanged ? { ...currentConfig, ns: true } : currentConfig;
+                        });
+                    }
+                }
+                if (inputBc != null) {
+                    const updateTemplateBc = (0, firebase_1.updateNotificationUserNotificationBoxRecipientConfigs)(updateTemplate.bc ?? notificationUser.bc, inputBc, appNotificationTemplateTypeInfoRecordService);
+                    if (updateTemplateBc != null) {
+                        updateTemplate.bc = updateTemplateBc;
+                        updateTemplate.b = updateTemplateBc.map((x) => x.nb);
+                    }
+                }
+                // if bc is being updated, then also update ns
+                if (updateTemplate.bc != null) {
+                    updateTemplate.ns = updateTemplate.bc.some((x) => x.ns);
+                }
+                await notificationUserDocumentInTransaction.update(updateTemplate);
+            });
+            return notificationUserDocument;
+        };
+    });
+}
+exports.updateNotificationUserFactory = updateNotificationUserFactory;
+const MAX_NOTIFICATION_BOXES_TO_UPDATE_PER_BATCH = 50;
+function resyncNotificationUserFactory(context) {
+    const { firestoreContext, firebaseServerActionTransformFunctionFactory, notificationBoxCollection, notificationUserCollection, appNotificationTemplateTypeInfoRecordService } = context;
+    return firebaseServerActionTransformFunctionFactory(firebase_1.ResyncNotificationUserParams, async (params) => {
+        return async (notificationUserDocument) => {
+            // run updates in batches
+            let notificationBoxesUpdated = 0;
+            let hasMoreNotificationBoxesToSync = true;
+            while (hasMoreNotificationBoxesToSync) {
+                const batchResult = await firestoreContext.runTransaction(async (transaction) => {
+                    const notificationUserDocumentInTransaction = notificationUserCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(notificationUserDocument);
+                    const notificationUser = await (0, firebase_server_1.assertSnapshotData)(notificationUserDocumentInTransaction);
+                    const { gc } = notificationUser;
+                    const notificationBoxConfigsToSync = notificationUser.bc.filter((x) => x.ns);
+                    const notificationBoxConfigsToSyncInThisBatch = (0, util_1.takeFront)(notificationBoxConfigsToSync, MAX_NOTIFICATION_BOXES_TO_UPDATE_PER_BATCH);
+                    /**
+                     * These are the actual number of NotificationBox values that had recipients updated.
+                     */
+                    let notificationBoxesUpdatedInBatch = 0;
+                    let hasUnsyncedNotificationBoxConfigs = false;
+                    if (notificationBoxConfigsToSyncInThisBatch.length > 0) {
+                        const notificationBoxConfigsToSyncInThisBatchMap = (0, util_1.makeModelMap)(notificationBoxConfigsToSyncInThisBatch, (x) => x.nb);
+                        const notificationBoxIdsToSyncInThisBatch = Array.from(notificationBoxConfigsToSyncInThisBatchMap.keys());
+                        const notificationBoxDocuments = (0, firebase_1.loadDocumentsForIds)(notificationBoxCollection.documentAccessorForTransaction(transaction), notificationBoxIdsToSyncInThisBatch);
+                        const notificationBoxDocumentSnapshotDataPairs = await (0, firebase_1.getDocumentSnapshotDataPairs)(notificationBoxDocuments);
+                        const notificationBoxConfigsToRemoveFromNotificationUser = new Set();
+                        const notificationUserNotificationBoxConfigsToMarkAsRemoved = new Set();
+                        const nextRecipientsMap = new Map();
+                        // update each NotificationBoxDocument
+                        await (0, util_1.performAsyncTasks)(notificationBoxDocumentSnapshotDataPairs, async (notificationBoxDocumentSnapshotDataPair) => {
+                            const { data: notificationBox, document } = notificationBoxDocumentSnapshotDataPair;
+                            const nb = document.id;
+                            const notificationUserNotificationBoxConfig = notificationBoxConfigsToSyncInThisBatchMap.get(nb); // always exists
+                            if (!notificationBox) {
+                                // if the entire NotificationBox no longer exists, flag to remove it from the user as a cleanup measure
+                                notificationBoxConfigsToRemoveFromNotificationUser.add(nb);
+                            }
+                            else {
+                                // update in the NotificationBox
+                                const recipientIndex = notificationBox.r.findIndex((x) => x.uid === notificationUser.uid);
+                                let r;
+                                if (recipientIndex === -1) {
+                                    // if they are not in the NotificationBox, then mark them as removed on the user
+                                    notificationUserNotificationBoxConfigsToMarkAsRemoved.add(nb);
+                                }
+                                else if (notificationUserNotificationBoxConfig.rm) {
+                                    // remove from the notification box if it is flagged
+                                    r = (0, util_1.removeValuesAtIndexesFromArrayCopy)(notificationBox.r, recipientIndex);
+                                }
+                                else {
+                                    const { m } = notificationBox;
+                                    const recipient = notificationBox.r[recipientIndex];
+                                    const nextRecipient = (0, firebase_1.effectiveNotificationBoxRecipientConfig)({
+                                        uid: notificationUser.uid,
+                                        m,
+                                        appNotificationTemplateTypeInfoRecordService,
+                                        gc,
+                                        boxConfig: notificationUserNotificationBoxConfig,
+                                        recipient
+                                    });
+                                    const recipientHasChange = !(0, util_1.areEqualPOJOValues)(nextRecipient, recipient);
+                                    // only update recipients if the next/new recipient is not equal to the existing one
+                                    if (recipientHasChange) {
+                                        r = [...notificationBox.r];
+                                        r[recipientIndex] = nextRecipient;
+                                        nextRecipientsMap.set(nb, nextRecipient);
+                                    }
+                                    else {
+                                        nextRecipientsMap.set(nb, recipient);
+                                    }
+                                }
+                                // update recipients if needed
+                                if (r != null) {
+                                    await document.update({ r });
+                                    notificationBoxesUpdatedInBatch += 1;
+                                }
+                            }
+                        });
+                        // Update the NotificationUser
+                        const notificationBoxIdsSynced = new Set(notificationBoxIdsToSyncInThisBatch);
+                        // start nextConfigs off as a new array with none of the sync'd ids
+                        const nextConfigs = notificationBoxConfigsToSyncInThisBatch.filter((x) => !notificationBoxIdsSynced.has(x.nb));
+                        notificationBoxIdsToSyncInThisBatch.forEach((nb) => {
+                            let nextConfig;
+                            if (notificationBoxConfigsToRemoveFromNotificationUser.has(nb)) {
+                                // do nothing, as it should be removed
+                            }
+                            else {
+                                const existingConfig = notificationBoxConfigsToSyncInThisBatchMap.get(nb);
+                                if (notificationUserNotificationBoxConfigsToMarkAsRemoved.has(nb) || existingConfig.rm) {
+                                    // if the recipient was being removed or is marked as removed, then update the config to confirm removal
+                                    nextConfig = {
+                                        ...existingConfig,
+                                        nb,
+                                        rm: true,
+                                        i: util_1.UNSET_INDEX_NUMBER
+                                    };
+                                }
+                                else {
+                                    // else, use the updated recipient and keep/copy the
+                                    const updatedRecipient = nextRecipientsMap.get(nb);
+                                    nextConfig = {
+                                        ...existingConfig,
+                                        nb,
+                                        rm: false,
+                                        i: updatedRecipient.i ?? util_1.UNSET_INDEX_NUMBER
+                                    };
+                                }
+                            }
+                            if (nextConfig != null) {
+                                nextConfig.ns = false; // mark as synced
+                                nextConfigs.push(nextConfig);
+                            }
+                        });
+                        const ns = nextConfigs.some((x) => x.ns);
+                        await notificationUserDocumentInTransaction.update({ bc: nextConfigs, ns });
+                        hasUnsyncedNotificationBoxConfigs = ns;
+                    }
+                    const batchResult = {
+                        hasMoreNotificationBoxesToSync: hasUnsyncedNotificationBoxConfigs,
+                        notificationBoxesUpdatedInBatch
+                    };
+                    return batchResult;
+                });
+                hasMoreNotificationBoxesToSync = batchResult.hasMoreNotificationBoxesToSync;
+                notificationBoxesUpdated += batchResult.notificationBoxesUpdatedInBatch;
+            }
+            const result = {
+                notificationBoxesUpdated
+            };
+            return result;
+        };
+    });
+}
+exports.resyncNotificationUserFactory = resyncNotificationUserFactory;
+function resyncAllNotificationUsersFactory(context) {
+    const { firestoreContext, firebaseServerActionTransformFunctionFactory, notificationUserCollection } = context;
+    const resyncNotificationUser = resyncNotificationUserFactory(context);
+    return async (params) => {
+        let notificationBoxesUpdated = 0;
+        const resyncNotificationUserParams = { key: (0, firebase_1.firestoreDummyKey)() };
+        const resyncNotificationUserInstance = await resyncNotificationUser(resyncNotificationUserParams);
+        const iterateResult = await (0, firebase_1.iterateFirestoreDocumentSnapshotPairs)({
+            documentAccessor: notificationUserCollection.documentAccessor(),
+            iterateSnapshotPair: async (snapshotPair) => {
+                const { document: notificationUserDocument } = snapshotPair;
+                const result = await resyncNotificationUserInstance(notificationUserDocument);
+                notificationBoxesUpdated += result.notificationBoxesUpdated;
+            },
+            constraintsFactory: () => (0, firebase_1.notificationUsersFlaggedForNeedsSyncQuery)(),
+            snapshotsPerformTasksConfig: {
+                // prevent NotificationUsers with the same NotificationBoxes from being updated/sync'd at the same time
+                nonConcurrentTaskKeyFactory: (x) => {
+                    const notificationBoxIdsToSync = x
+                        .data()
+                        .bc.filter((x) => x.ns)
+                        .map((x) => x.nb);
+                    return notificationBoxIdsToSync;
+                }
+            },
+            queryFactory: notificationUserCollection,
+            batchSize: undefined,
+            performTasksConfig: {
+                maxParallelTasks: 10
+            }
+        });
+        const result = {
+            notificationUsersResynced: iterateResult.totalSnapshotsVisited,
+            notificationBoxesUpdated
+        };
+        return result;
+    };
+}
+exports.resyncAllNotificationUsersFactory = resyncAllNotificationUsersFactory;
+function createNotificationSummaryFactory(context) {
+    const { firebaseServerActionTransformFunctionFactory, notificationSummaryCollection, authService } = context;
+    return firebaseServerActionTransformFunctionFactory(firebase_1.CreateNotificationSummaryParams, async (params) => {
+        const { model } = params;
+        return async () => {
+            const notificationSummaryId = (0, firebase_1.notificationSummaryIdForModel)(model);
+            const notificationSummaryDocument = notificationSummaryCollection.documentAccessor().loadDocumentForId(notificationSummaryId);
+            const newSummaryTemplate = (0, notification_util_1.makeNewNotificationSummaryTemplate)(model);
+            await notificationSummaryDocument.create(newSummaryTemplate);
+            return notificationSummaryDocument;
+        };
+    });
+}
+exports.createNotificationSummaryFactory = createNotificationSummaryFactory;
+function updateNotificationSummaryFactory(context) {
+    const { firebaseServerActionTransformFunctionFactory, notificationSummaryCollection } = context;
+    return firebaseServerActionTransformFunctionFactory(firebase_1.UpdateNotificationSummaryParams, async (params) => {
+        const { setReadAtTime, flagAllRead } = params;
+        return async (notificationSummaryDocument) => {
+            let updateTemplate;
+            if (setReadAtTime != null) {
+                updateTemplate = { rat: setReadAtTime };
+            }
+            else if (flagAllRead === true) {
+                updateTemplate = { rat: new Date() };
+            }
+            if (updateTemplate != null) {
+                await notificationSummaryDocument.update(updateTemplate);
+            }
+            return notificationSummaryDocument;
+        };
+    });
+}
+exports.updateNotificationSummaryFactory = updateNotificationSummaryFactory;
+function createNotificationBoxInTransactionFactory(context) {
+    const { notificationBoxCollection } = context;
+    return async (params, transaction) => {
+        const { now = new Date(), model } = params;
+        const notificationBoxId = (0, firebase_1.notificationBoxIdForModel)(model);
+        const notificationBoxDocument = notificationBoxCollection.documentAccessorForTransaction(transaction).loadDocumentForId(notificationBoxId);
+        const notificationBoxTemplate = {
+            m: model,
+            o: (0, firebase_1.firestoreDummyKey)(),
+            r: [],
+            cat: now,
+            w: (0, date_1.yearWeekCode)(now),
+            s: true // requires initialization
+        };
+        await notificationBoxDocument.create(notificationBoxTemplate);
+        return {
+            notificationBoxTemplate,
+            notificationBoxDocument
+        };
+    };
+}
+exports.createNotificationBoxInTransactionFactory = createNotificationBoxInTransactionFactory;
+function createNotificationBoxFactory(context) {
+    const { firestoreContext, authService, notificationBoxCollection, firebaseServerActionTransformFunctionFactory } = context;
+    const createNotificationBoxInTransaction = createNotificationBoxInTransactionFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase_1.CreateNotificationBoxParams, async (params) => {
+        const { model } = params;
+        return async () => {
+            const result = await firestoreContext.runTransaction(async (transaction) => {
+                const { notificationBoxDocument } = await createNotificationBoxInTransaction({
+                    model
+                }, transaction);
+                return notificationBoxDocument;
+            });
+            return notificationBoxCollection.documentAccessor().loadDocumentFrom(result);
+        };
+    });
+}
+exports.createNotificationBoxFactory = createNotificationBoxFactory;
+function updateNotificationBoxFactory({ firebaseServerActionTransformFunctionFactory }) {
+    return firebaseServerActionTransformFunctionFactory(firebase_1.UpdateNotificationBoxParams, async () => {
+        return async (notificationBoxDocument) => {
+            // does nothing currently.
+            return notificationBoxDocument;
+        };
+    });
+}
+exports.updateNotificationBoxFactory = updateNotificationBoxFactory;
+function updateNotificationBoxRecipientFactory({ firestoreContext, authService, notificationBoxCollection, notificationUserCollection, firebaseServerActionTransformFunctionFactory }) {
+    return firebaseServerActionTransformFunctionFactory(firebase_1.UpdateNotificationBoxRecipientParams, async (params) => {
+        const { uid, i, insert, remove, configs: inputC } = params;
+        const findRecipientFn = (x) => (uid != null && x.uid === uid) || (i != null && i === i);
+        return async (notificationBoxDocument) => {
+            await firestoreContext.runTransaction(async (transaction) => {
+                const notificationBoxDocumentInTransaction = notificationBoxCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(notificationBoxDocument);
+                const notificationBox = await (0, firebase_server_1.assertSnapshotData)(notificationBoxDocumentInTransaction);
+                const { m } = notificationBox;
+                let r;
+                let targetRecipientIndex = notificationBox.r.findIndex(findRecipientFn);
+                const targetRecipient = notificationBox.r[targetRecipientIndex];
+                let nextRecipient;
+                if (remove) {
+                    if (targetRecipientIndex != null) {
+                        r = [...notificationBox.r]; // remove if they exist.
+                        delete r[targetRecipientIndex];
+                    }
+                }
+                else {
+                    if (!targetRecipient && !insert) {
+                        throw (0, notification_error_1.notificationBoxRecipientDoesNotExistsError)();
+                    }
+                    const c = (inputC != null ? (0, firebase_1.notificationBoxRecipientTemplateConfigArrayToRecord)(inputC) : targetRecipient?.c) ?? {};
+                    nextRecipient = {
+                        uid,
+                        i: targetRecipient?.i ?? util_1.UNSET_INDEX_NUMBER,
+                        c,
+                        ...(0, firebase_1.updateNotificationRecipient)(targetRecipient ?? {}, params)
+                    };
+                    r = [...notificationBox.r];
+                    if (targetRecipient) {
+                        nextRecipient.i = targetRecipient.i;
+                        nextRecipient = (0, firebase_1.mergeNotificationBoxRecipients)(targetRecipient, nextRecipient);
+                        r[targetRecipientIndex] = nextRecipient; // override in the array
+                    }
+                    else {
+                        const nextI = (0, util_1.computeNextFreeIndexOnSortedValuesFunction)(util_1.readIndexNumber)(notificationBox.r); // r is sorted by index in ascending order, so the last value is the largest i
+                        nextRecipient.i = nextI;
+                        // should have the greatest i value, push to end
+                        r.push(nextRecipient);
+                        targetRecipientIndex = r.length - 1;
+                    }
+                }
+                // save changes to r if it changed
+                if (r != null) {
+                    const notificationUserId = targetRecipient?.uid ?? nextRecipient?.uid;
+                    // sync with the notification user's document, if it exists
+                    if (notificationUserId != null) {
+                        const notificationBoxId = notificationBoxDocument.id;
+                        const notificationUserDocument = await notificationUserCollection.documentAccessorForTransaction(transaction).loadDocumentForId(notificationUserId);
+                        let notificationUser = await notificationUserDocument.snapshotData();
+                        const createNotificationUser = !notificationUser && !remove && insert;
+                        if (createNotificationUser) {
+                            // assert they exist in the auth system
+                            const userContext = authService.userContext(notificationUserId);
+                            const userExistsInAuth = await userContext.exists();
+                            if (!userExistsInAuth) {
+                                throw (0, notification_error_1.notificationUserInvalidUidForCreateError)(notificationUserId);
+                            }
+                            const notificationUserTemplate = {
+                                uid: notificationUserId,
+                                b: [],
+                                bc: [],
+                                ns: false,
+                                dc: {
+                                    c: {}
+                                },
+                                gc: {
+                                    c: {}
+                                }
+                            };
+                            notificationUser = notificationUserTemplate;
+                        }
+                        // if the user is being inserted or exists, then make updates
+                        if (notificationUser != null) {
+                            const { updatedBc, updatedNotificationBoxRecipient } = (0, notification_util_1.updateNotificationUserNotificationBoxRecipientConfig)({
+                                notificationBoxId,
+                                notificationUserId,
+                                notificationBoxAssociatedModelKey: m,
+                                notificationUser,
+                                insertingRecipientIntoNotificationBox: insert,
+                                removeRecipientFromNotificationBox: remove,
+                                notificationBoxRecipient: nextRecipient
+                            });
+                            const updatedB = updatedBc ? updatedBc.map((x) => x.nb) : undefined;
+                            if (createNotificationUser) {
+                                const newUserTemplate = {
+                                    ...notificationUser,
+                                    bc: updatedBc ?? [],
+                                    b: updatedB ?? []
+                                };
+                                await notificationUserDocument.create(newUserTemplate);
+                            }
+                            else if (updatedBc != null) {
+                                await notificationUserDocument.update({ bc: updatedBc, b: updatedB });
+                            }
+                            // Set if nextRecipient is updated/influence from existing configuration
+                            if (targetRecipientIndex != null && updatedNotificationBoxRecipient && !remove) {
+                                r[targetRecipientIndex] = updatedNotificationBoxRecipient; // set the updated value in r
+                            }
+                        }
+                        // else, if removing and they don't exist, nothing to update
+                    }
+                    await notificationBoxDocumentInTransaction.update({ r });
+                }
+            });
+            return notificationBoxDocument;
+        };
+    });
+}
+exports.updateNotificationBoxRecipientFactory = updateNotificationBoxRecipientFactory;
+exports.UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY = 8;
+exports.UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS = 1;
+exports.KNOWN_BUT_UNCONFIGURED_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY = exports.UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY;
+exports.KNOWN_BUT_UNCONFIGURED_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS = 5;
+exports.NOTIFICATION_MAX_SEND_ATTEMPTS = 5;
+exports.NOTIFICATION_BOX_NOT_INITIALIZED_DELAY_MINUTES = 8;
+function sendNotificationFactory(context) {
+    const { appNotificationTemplateTypeInfoRecordService, notificationSendService, notificationTemplateService, authService, notificationBoxCollection, notificationCollectionGroup, notificationUserCollection, firestoreContext, firebaseServerActionTransformFunctionFactory } = context;
+    const createNotificationBoxInTransaction = createNotificationBoxInTransactionFactory(context);
+    const notificationUserAccessor = notificationUserCollection.documentAccessor();
+    return firebaseServerActionTransformFunctionFactory(firebase_1.SendNotificationParams, async (params) => {
+        const { ignoreSendAtThrottle } = params;
+        return async (notificationDocument) => {
+            // does nothing currently.
+            const { throttled, tryRun, notification, createdBox, notificationBoxNeedsInitialization, notificationBox, notificationBoxModelKey, deletedNotification, templateInstance, isConfiguredTemplateType, isKnownTemplateType } = await firestoreContext.runTransaction(async (transaction) => {
+                const notificationBoxDocument = notificationBoxCollection.documentAccessorForTransaction(transaction).loadDocument(notificationDocument.parent);
+                const notificationDocumentInTransaction = notificationCollectionGroup.documentAccessorForTransaction(transaction).loadDocumentFrom(notificationDocument);
+                let [notificationBox, notification] = await Promise.all([notificationBoxDocument.snapshotData(), (0, firebase_1.getDocumentSnapshotData)(notificationDocumentInTransaction)]);
+                const model = (0, firebase_1.inferKeyFromTwoWayFlatFirestoreModelKey)(notificationBoxDocument.id);
+                let tryRun = true;
+                let throttled = false;
+                let nextSat;
+                if (!notification) {
+                    tryRun = false;
+                }
+                else if (!ignoreSendAtThrottle) {
+                    tryRun = (0, date_fns_1.isPast)(notification.sat);
+                    if (tryRun) {
+                        nextSat = (0, date_fns_1.addMinutes)(new Date(), 10); // try again in 10 minutes if not successful
+                    }
+                    else {
+                        throttled = true;
+                    }
+                }
+                let createdBox = false;
+                let deletedNotification = false;
+                let notificationBoxNeedsInitialization = false;
+                let isKnownTemplateType;
+                let isConfiguredTemplateType;
+                let templateInstance;
+                async function deleteNotification() {
+                    tryRun = false;
+                    await notificationDocumentInTransaction.accessor.delete();
+                    deletedNotification = true;
+                }
+                // create/init the notification box if necessary/configured.
+                if (notification && tryRun) {
+                    // if we're still trying to run, check the template is ok. If not, cancel the run.
+                    const { t } = notification.n;
+                    templateInstance = notificationTemplateService.templateInstanceForType(t);
+                    isKnownTemplateType = isConfiguredTemplateType = templateInstance.isConfiguredType;
+                    if (!isConfiguredTemplateType) {
+                        // log the issue that an notification with an unconfigured type was queued
+                        const templateInfo = appNotificationTemplateTypeInfoRecordService.appNotificationTemplateTypeInfoRecord[t];
+                        isKnownTemplateType = templateInfo != null;
+                        const retryAttempts = isKnownTemplateType ? exports.KNOWN_BUT_UNCONFIGURED_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS : exports.UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS;
+                        const delay = isKnownTemplateType ? exports.KNOWN_BUT_UNCONFIGURED_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY : exports.UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY;
+                        if (notification.a < retryAttempts) {
+                            if (isKnownTemplateType) {
+                                console.warn(`Unconfigured but known template type of "${t}" (${templateInfo.name}) was found in a Notification. Send is being delayed by ${delay} hours.`);
+                            }
+                            else {
+                                console.warn(`Unknown template type of "${t}" was found in a Notification. Send is being delayed by ${delay} hours.`);
+                            }
+                            // delay send for 12 hours, for a max of 24 hours incase it is an issue.
+                            nextSat = (0, date_fns_1.addHours)(new Date(), delay);
+                            tryRun = false;
+                        }
+                        else {
+                            console.warn(`Unconfigured template type of "${t}" was found in a Notification. The Notification has reached the delete threshhold after failing to send due to misconfiguration multiple times and is being deleted.`);
+                            // after attempting to send 3 times, delete it.
+                            await deleteNotification();
+                        }
+                    }
+                    // handle the notification box's absence
+                    if (!notificationBox && tryRun) {
+                        switch (notification.st) {
+                            case firebase_1.NotificationSendType.INIT_BOX_AND_SEND:
+                                const { notificationBoxTemplate } = await createNotificationBoxInTransaction({
+                                    model
+                                }, transaction);
+                                notificationBox = notificationBoxTemplate;
+                                createdBox = true;
+                                break;
+                            case firebase_1.NotificationSendType.SEND_IF_BOX_EXISTS:
+                                // delete the notification since it won't get sent.
+                                await deleteNotification();
+                                break;
+                            case firebase_1.NotificationSendType.SEND_WITHOUT_CREATING_BOX:
+                                // continue with current tryRun
+                                break;
+                        }
+                    }
+                    // if the notification box is not initialized/synchronized yet, do not run.
+                    if (tryRun && notificationBox && notificationBox.s) {
+                        notificationBoxNeedsInitialization = true;
+                        tryRun = false;
+                        nextSat = (0, date_fns_1.addMinutes)(new Date(), exports.NOTIFICATION_BOX_NOT_INITIALIZED_DELAY_MINUTES);
+                    }
+                }
+                // update the notification send at time and attempt count
+                if (notification != null && nextSat != null && !deletedNotification) {
+                    const isAtMaxAttempts = notification.a >= exports.NOTIFICATION_MAX_SEND_ATTEMPTS;
+                    if (isAtMaxAttempts && notificationBoxNeedsInitialization) {
+                        await deleteNotification(); // just delete the notification if the box still hasn't been initialized successfully at this point.
+                    }
+                    if (!deletedNotification) {
+                        await notificationDocumentInTransaction.update({ sat: nextSat, a: notification.a + 1 });
+                    }
+                }
+                return {
+                    throttled,
+                    deletedNotification,
+                    createdBox,
+                    notificationBoxModelKey: model,
+                    notificationBoxNeedsInitialization,
+                    notificationBox,
+                    notification,
+                    templateInstance,
+                    isKnownTemplateType,
+                    isConfiguredTemplateType,
+                    tryRun
+                };
+            });
+            let success = false;
+            let sendEmailsResult;
+            let sendTextsResult;
+            let sendNotificationSummaryResult;
+            let loadMessageFunctionFailure = false;
+            let buildMessageFailure = false;
+            let notificationMarkedDone = false;
+            const notificationTemplateType = templateInstance?.type;
+            // notification is only null/undefined if it didn't exist.
+            if (notification != null) {
+                if (tryRun && templateInstance != null) {
+                    // first load the message function
+                    const messageFunction = await templateInstance
+                        .loadMessageFunction({
+                        item: notification.n,
+                        notification,
+                        notificationBox: {
+                            m: notificationBoxModelKey
+                        }
+                    })
+                        .catch((e) => {
+                        loadMessageFunctionFailure = true;
+                        success = false;
+                        console.error(`Failed loading message function for type ${notificationTemplateType}: `, e);
+                        return undefined;
+                    });
+                    if (messageFunction) {
+                        // expand recipients
+                        const { emails: emailRecipients, texts: textRecipients, notificationSummaries: notificationSummaryRecipients } = await (0, notification_util_1.expandNotificationRecipients)({
+                            notification,
+                            notificationBox,
+                            authService,
+                            notificationUserAccessor,
+                            globalRecipients: messageFunction.globalRecipients,
+                            notificationSummaryIdForUid: notificationSendService.notificationSummaryIdForUidFunction
+                        });
+                        let { es, ts, ps, ns, esr: currentEsr, tsr: currentTsr } = notification;
+                        // do emails
+                        let esr;
+                        if (es === firebase_1.NotificationSendState.QUEUED || es === firebase_1.NotificationSendState.SENT_PARTIAL) {
+                            const emailRecipientsAlreadySentTo = new Set(currentEsr.map((x) => x.toLowerCase()));
+                            const emailInputContexts = emailRecipients
+                                .filter((x) => !emailRecipientsAlreadySentTo.has(x.emailAddress.toLowerCase()))
+                                .map((x) => {
+                                const context = {
+                                    recipient: {
+                                        n: x.name,
+                                        e: x.emailAddress,
+                                        t: x.phoneNumber
+                                    }
+                                };
+                                return context;
+                            });
+                            const emailMessages = await Promise.all(emailInputContexts.map(messageFunction)).catch((e) => {
+                                console.error(`Failed building message function for type ${notificationTemplateType}: `, e);
+                                buildMessageFailure = true;
+                                return undefined;
+                            });
+                            if (emailMessages?.length) {
+                                if (notificationSendService.emailSendService != null) {
+                                    let sendInstance;
+                                    try {
+                                        sendInstance = await notificationSendService.emailSendService.buildSendInstanceForEmailNotificationMessages(emailMessages);
+                                    }
+                                    catch (e) {
+                                        console.error(`Failed building email send instance for notification "${notification.id}" with type "${notificationTemplateType}": `, e);
+                                        es = firebase_1.NotificationSendState.CONFIG_ERROR;
+                                    }
+                                    if (sendInstance) {
+                                        try {
+                                            sendEmailsResult = await sendInstance();
+                                        }
+                                        catch (e) {
+                                            console.error(`Failed sending email notification "${notification.id}" with type "${notificationTemplateType}": `, e);
+                                            es = firebase_1.NotificationSendState.SEND_ERROR;
+                                        }
+                                    }
+                                }
+                                else {
+                                    console.error(`Failed sending email notification "${notification.id}" with type "${notificationTemplateType}" due to no email service being configured.`);
+                                    es = firebase_1.NotificationSendState.CONFIG_ERROR;
+                                }
+                                if (sendEmailsResult != null) {
+                                    const { success, failed } = sendEmailsResult;
+                                    esr = success.length ? currentEsr.concat(success.map((x) => x.toLowerCase())) : undefined;
+                                    if (failed.length > 0) {
+                                        es = firebase_1.NotificationSendState.SENT_PARTIAL;
+                                    }
+                                    else {
+                                        es = firebase_1.NotificationSendState.SENT;
+                                    }
+                                }
+                            }
+                            else {
+                                es = firebase_1.NotificationSendState.SENT;
+                            }
+                        }
+                        // do phone numbers
+                        let tsr;
+                        if (ts === firebase_1.NotificationSendState.QUEUED || ts === firebase_1.NotificationSendState.SENT_PARTIAL) {
+                            const textRecipientsAlreadySentTo = new Set(currentTsr);
+                            const textInputContexts = textRecipients
+                                .filter((x) => !textRecipientsAlreadySentTo.has(x.phoneNumber))
+                                .map((x) => {
+                                const context = {
+                                    recipient: {
+                                        n: x.name,
+                                        e: x.emailAddress,
+                                        t: x.phoneNumber
+                                    }
+                                };
+                                return context;
+                            });
+                            const textMessages = await Promise.all(textInputContexts.map(messageFunction)).catch((e) => {
+                                console.error(`Failed building message function for type ${notificationTemplateType}: `, e);
+                                buildMessageFailure = true;
+                                return undefined;
+                            });
+                            if (textMessages?.length) {
+                                if (notificationSendService.textSendService != null) {
+                                    let sendInstance;
+                                    try {
+                                        sendInstance = await notificationSendService.textSendService.buildSendInstanceForTextNotificationMessages(textMessages);
+                                    }
+                                    catch (e) {
+                                        console.error(`Failed building text send instance for notification "${notification.id}" with type "${notificationTemplateType}": `, e);
+                                        ts = firebase_1.NotificationSendState.CONFIG_ERROR;
+                                    }
+                                    if (sendInstance) {
+                                        try {
+                                            sendTextsResult = await sendInstance();
+                                        }
+                                        catch (e) {
+                                            console.error(`Failed sending text notification "${notification.id}" with type "${notificationTemplateType}": `, e);
+                                            ts = firebase_1.NotificationSendState.SEND_ERROR;
+                                        }
+                                    }
+                                }
+                                else {
+                                    console.error(`Failed sending text notification "${notification.id}" with type "${notificationTemplateType}" due to no text service being configured.`);
+                                    ts = firebase_1.NotificationSendState.CONFIG_ERROR;
+                                }
+                                if (sendTextsResult != null) {
+                                    const { success, failed, ignored } = sendTextsResult;
+                                    tsr = success.length ? currentTsr.concat(success) : undefined;
+                                    if (failed.length > 0) {
+                                        ts = firebase_1.NotificationSendState.SENT_PARTIAL;
+                                    }
+                                    else {
+                                        ts = firebase_1.NotificationSendState.SENT;
+                                    }
+                                }
+                            }
+                            else {
+                                ts = firebase_1.NotificationSendState.SENT;
+                            }
+                        }
+                        ps = firebase_1.NotificationSendState.NO_TRY;
+                        // NOTE: FCM token management will probably done with a separate system within Notification that stores FCMs for specific users in the app. May also use UIDs to determine who got the push notificdation or not...
+                        // do notification summaries
+                        if (ns === firebase_1.NotificationSendState.QUEUED || ns === firebase_1.NotificationSendState.SENT_PARTIAL) {
+                            const notificationSummaryInputContexts = notificationSummaryRecipients.map((x) => {
+                                const context = {
+                                    recipient: {
+                                        n: x.name,
+                                        s: x.notificationSummaryId
+                                    }
+                                };
+                                return context;
+                            });
+                            const notificationSummaryMessages = await Promise.all(notificationSummaryInputContexts.map(messageFunction)).catch((e) => {
+                                console.error(`Failed building message function for type ${notificationTemplateType}: `, e);
+                                buildMessageFailure = true;
+                                return undefined;
+                            });
+                            if (notificationSummaryMessages?.length) {
+                                if (notificationSendService.notificationSummarySendService != null) {
+                                    let sendInstance;
+                                    try {
+                                        sendInstance = await notificationSendService.notificationSummarySendService.buildSendInstanceForNotificationSummaryMessages(notificationSummaryMessages);
+                                    }
+                                    catch (e) {
+                                        console.error(`Failed building notification summary send instance for notification "${notification.id}" with type "${notificationTemplateType}": `, e);
+                                        ns = firebase_1.NotificationSendState.CONFIG_ERROR;
+                                    }
+                                    if (sendInstance) {
+                                        try {
+                                            sendNotificationSummaryResult = await sendInstance();
+                                            ns = firebase_1.NotificationSendState.SENT;
+                                        }
+                                        catch (e) {
+                                            console.error(`Failed sending notification summary notification "${notification.id}" with type "${notificationTemplateType}": `, e);
+                                            ns = firebase_1.NotificationSendState.SEND_ERROR;
+                                        }
+                                    }
+                                }
+                                else {
+                                    console.error(`Failed sending notification summary notification "${notification.id}" with type "${notificationTemplateType}" due to no notification summary service being configured.`);
+                                    ns = firebase_1.NotificationSendState.CONFIG_ERROR;
+                                }
+                            }
+                            else {
+                                ns = firebase_1.NotificationSendState.SENT;
+                            }
+                        }
+                        // calculate results
+                        const notificationTemplate = { es, ts, ps, ns, esr, tsr };
+                        success = (0, firebase_1.notificationSendFlagsImplyIsComplete)(notificationTemplate);
+                        if (success) {
+                            notificationTemplate.d = true;
+                        }
+                        else {
+                            notificationTemplate.a = notification.a + 1;
+                            if (notificationTemplate.a >= exports.NOTIFICATION_MAX_SEND_ATTEMPTS) {
+                                notificationTemplate.d = true;
+                            }
+                        }
+                        await notificationDocument.update(notificationTemplate);
+                        notificationMarkedDone = notificationTemplate.d === true;
+                    }
+                }
+                else {
+                    switch (notification.st) {
+                        case firebase_1.NotificationSendType.SEND_IF_BOX_EXISTS:
+                            // deleted successfully
+                            success = deletedNotification;
+                            break;
+                    }
+                }
+            }
+            const result = {
+                notificationTemplateType,
+                isKnownTemplateType,
+                isConfiguredTemplateType,
+                throttled,
+                exists: notification != null,
+                boxExists: notificationBox != null,
+                notificationBoxNeedsInitialization,
+                createdBox,
+                deletedNotification,
+                notificationMarkedDone,
+                tryRun,
+                success,
+                sendEmailsResult,
+                sendTextsResult,
+                sendNotificationSummaryResult,
+                loadMessageFunctionFailure,
+                buildMessageFailure
+            };
+            return result;
+        };
+    });
+}
+exports.sendNotificationFactory = sendNotificationFactory;
+function sendQueuedNotificationsFactory(context) {
+    const { firebaseServerActionTransformFunctionFactory, notificationCollectionGroup } = context;
+    const sendNotification = sendNotificationFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase_1.SendQueuedNotificationsParams, async () => {
+        return async () => {
+            let notificationBoxesCreated = 0;
+            let notificationsDeleted = 0;
+            let notificationsVisited = 0;
+            let notificationsSucceeded = 0;
+            let notificationsDelayed = 0;
+            let notificationsFailed = 0;
+            let sendEmailsResult;
+            let sendTextsResult;
+            let sendNotificationSummaryResult;
+            const sendNotificationParams = { key: (0, firebase_1.firestoreDummyKey)(), throwErrorIfSent: false };
+            const sendNotificationInstance = await sendNotification(sendNotificationParams);
+            // iterate through all JobApplication items that need to be synced
+            while (true) {
+                const sendQueuedNotificationsResults = await sendQueuedNotifications();
+                sendQueuedNotificationsResults.results.forEach((x) => {
+                    const result = x[1];
+                    if (result.success) {
+                        notificationsSucceeded += 1;
+                    }
+                    else if (result.createdBox || result.notificationBoxNeedsInitialization) {
+                        notificationsDelayed = 1;
+                    }
+                    else {
+                        notificationsFailed += 1;
+                    }
+                    if (result.deletedNotification) {
+                        notificationsDeleted += 1;
+                    }
+                    if (result.createdBox) {
+                        notificationBoxesCreated += 1;
+                    }
+                    sendEmailsResult = (0, firebase_1.mergeNotificationSendMessagesResult)(sendEmailsResult, result.sendEmailsResult);
+                    sendTextsResult = (0, firebase_1.mergeNotificationSendMessagesResult)(sendTextsResult, result.sendTextsResult);
+                    sendNotificationSummaryResult = (0, firebase_1.mergeNotificationSendMessagesResult)(sendNotificationSummaryResult, result.sendNotificationSummaryResult);
+                });
+                const found = sendQueuedNotificationsResults.results.length;
+                notificationsVisited += found;
+                if (!found) {
+                    break;
+                }
+            }
+            async function sendQueuedNotifications() {
+                const query = notificationCollectionGroup.queryDocument((0, firebase_1.notificationsPastSendAtTimeQuery)());
+                const notificationDocuments = await query.getDocs();
+                const result = await (0, util_1.performAsyncTasks)(notificationDocuments, async (notificationDocument) => {
+                    const result = await sendNotificationInstance(notificationDocument);
+                    return result;
+                }, {
+                    maxParallelTasks: 10
+                });
+                return result;
+            }
+            const result = {
+                notificationBoxesCreated,
+                notificationsDeleted,
+                notificationsVisited,
+                notificationsSucceeded,
+                notificationsDelayed,
+                notificationsFailed,
+                sendEmailsResult,
+                sendTextsResult,
+                sendNotificationSummaryResult
+            };
+            return result;
+        };
+    });
+}
+exports.sendQueuedNotificationsFactory = sendQueuedNotificationsFactory;
+function cleanupSentNotificationsFactory(context) {
+    const { firestoreContext, firebaseServerActionTransformFunctionFactory, notificationCollectionGroup, notificationCollectionFactory, notificationBoxCollection, notificationWeekCollectionFactory } = context;
+    return firebaseServerActionTransformFunctionFactory(firebase_1.CleanupSentNotificationsParams, async () => {
+        return async () => {
+            let notificationBoxesUpdatesCount = 0;
+            let notificationsDeleted = 0;
+            let notificationWeeksCreated = 0;
+            let notificationWeeksUpdated = 0;
+            // iterate through all JobApplication items that need to be synced
+            while (true) {
+                const cleanupSentNotificationsResults = await cleanupSentNotifications();
+                cleanupSentNotificationsResults.results.forEach((x) => {
+                    const { itemsDeleted, weeksCreated, weeksUpdated } = x[1];
+                    notificationsDeleted += itemsDeleted;
+                    notificationWeeksCreated += weeksCreated;
+                    notificationWeeksUpdated += weeksUpdated;
+                });
+                const notificationBoxesUpdated = cleanupSentNotificationsResults.results.length;
+                notificationBoxesUpdatesCount += notificationBoxesUpdated;
+                if (!notificationBoxesUpdated) {
+                    break;
+                }
+            }
+            async function cleanupSentNotifications() {
+                const query = notificationCollectionGroup.queryDocument((0, firebase_1.notificationsReadyForCleanupQuery)());
+                const notificationDocuments = await query.getDocs();
+                const notificationDocumentsGroupedByNotificationBox = Array.from((0, util_1.makeValuesGroupMap)(notificationDocuments, (x) => x.parent.id).values());
+                const result = await (0, util_1.performAsyncTasks)(notificationDocumentsGroupedByNotificationBox, async (notificationDocumentsInSameBox) => {
+                    const allPairs = await (0, firebase_1.getDocumentSnapshotDataPairs)(notificationDocumentsInSameBox);
+                    const allPairsWithDataAndMarkedDeleted = allPairs.filter((x) => x.data?.d);
+                    const pairsGroupedByWeek = Array.from((0, util_1.makeValuesGroupMap)(allPairsWithDataAndMarkedDeleted, (x) => (0, date_1.yearWeekCode)(x.data.sat)).entries());
+                    // batch incase there are a lot of new notifications to move to week
+                    const pairsGroupedByWeekInBatches = pairsGroupedByWeek
+                        .map((x) => {
+                        const batches = (0, util_1.batch)(x[1], 40);
+                        return batches.map((batch) => [x[0], batch]);
+                    })
+                        .flat();
+                    const notificationBoxDocument = await notificationBoxCollection.documentAccessor().loadDocument(notificationDocumentsInSameBox[0].parent);
+                    // create/update the NotificationWeek
+                    const notificationWeekResults = await (0, util_1.performAsyncTasks)(pairsGroupedByWeekInBatches, async ([yearWeekCode, notificationDocumentsInSameWeek]) => {
+                        return firestoreContext.runTransaction(async (transaction) => {
+                            const notificationWeekDocument = notificationWeekCollectionFactory(notificationBoxDocument).documentAccessorForTransaction(transaction).loadDocumentForId(`${yearWeekCode}`);
+                            const notificationDocumentsInTransaction = (0, firebase_1.loadDocumentsForDocumentReferencesFromValues)(notificationCollectionGroup.documentAccessorForTransaction(transaction), notificationDocumentsInSameWeek, (x) => x.snapshot.ref);
+                            const notificationWeek = await notificationWeekDocument.snapshotData();
+                            const newItems = (0, util_1.filterMaybeArrayValues)(notificationDocumentsInSameWeek.map((x) => {
+                                const data = x.data;
+                                const shouldSaveToNotificationWeek = (0, firebase_1.shouldSaveNotificationToNotificationWeek)(data);
+                                return shouldSaveToNotificationWeek ? data.n : undefined;
+                            }));
+                            const n = [...(notificationWeek?.n ?? []), ...newItems];
+                            if (!notificationWeek) {
+                                // create
+                                await notificationWeekDocument.create({
+                                    w: yearWeekCode,
+                                    n
+                                });
+                            }
+                            else {
+                                // update
+                                await notificationWeekDocument.update({
+                                    n
+                                });
+                            }
+                            // delete the notification items
+                            await Promise.all(notificationDocumentsInTransaction.map((x) => x.accessor.delete()));
+                            return {
+                                created: !notificationWeek
+                            };
+                        });
+                    });
+                    let weeksCreated = 0;
+                    let weeksUpdated = 0;
+                    notificationWeekResults.results.forEach((x) => {
+                        if (x[1].created) {
+                            weeksCreated += 1;
+                        }
+                        else {
+                            weeksUpdated += 1;
+                        }
+                    });
+                    const result = {
+                        weeksCreated,
+                        weeksUpdated,
+                        itemsDeleted: allPairsWithDataAndMarkedDeleted.length
+                    };
+                    return result;
+                }, {
+                    maxParallelTasks: 10
+                });
+                return result;
+            }
+            const result = {
+                notificationBoxesUpdatesCount,
+                notificationsDeleted,
+                notificationWeeksCreated,
+                notificationWeeksUpdated
+            };
+            return result;
+        };
+    });
+}
+exports.cleanupSentNotificationsFactory = cleanupSentNotificationsFactory;
+//# sourceMappingURL=notification.action.server.js.map