@dereekb/firebase-server 12.6.21 → 13.0.0

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

@@ -1,1487 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SEND_QUEUE_NOTIFICATIONS_TASK_EXCESS_THRESHOLD = exports.NOTIFICATION_TASK_TYPE_FAILURE_DELAY_MS = exports.NOTIFICATION_TASK_TYPE_FAILURE_DELAY_HOURS = exports.NOTIFICATION_TASK_TYPE_MAX_SEND_ATTEMPTS = exports.NOTIFICATION_TASK_MINIMUM_SET_AT_THROTTLE_TIME_MINUTES = 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_TASK_TYPE_DELETE_AFTER_RETRY_ATTEMPTS = exports.UNKNOWN_NOTIFICATION_TASK_TYPE_HOURS_DELAY = exports.UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS = exports.UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY = exports.NotificationServerActions = exports.NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN = exports.BASE_NOTIFICATION_SERVER_ACTION_CONTEXT_TOKEN = void 0;
-exports.notificationServerActions = notificationServerActions;
-exports.createNotificationUserFactory = createNotificationUserFactory;
-exports.updateNotificationUserFactory = updateNotificationUserFactory;
-exports.resyncNotificationUserFactory = resyncNotificationUserFactory;
-exports.resyncAllNotificationUsersFactory = resyncAllNotificationUsersFactory;
-exports.createNotificationSummaryFactory = createNotificationSummaryFactory;
-exports.updateNotificationSummaryFactory = updateNotificationSummaryFactory;
-exports.createNotificationBoxInTransactionFactory = createNotificationBoxInTransactionFactory;
-exports.createNotificationBoxFactory = createNotificationBoxFactory;
-exports.updateNotificationBoxFactory = updateNotificationBoxFactory;
-exports.updateNotificationBoxRecipientExclusionInTransactionFactory = updateNotificationBoxRecipientExclusionInTransactionFactory;
-exports.updateNotificationBoxRecipientInTransactionFactory = updateNotificationBoxRecipientInTransactionFactory;
-exports.updateNotificationBoxRecipientFactory = updateNotificationBoxRecipientFactory;
-exports.sendNotificationFactory = sendNotificationFactory;
-exports.sendQueuedNotificationsFactory = sendQueuedNotificationsFactory;
-exports.cleanupSentNotificationsFactory = cleanupSentNotificationsFactory;
-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");
-const notification_task_service_util_1 = require("./notification.task.service.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)
-    };
-}
-// 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,
-                x: [],
-                bc: [],
-                b: [],
-                dc: {
-                    c: {}
-                },
-                gc: {
-                    c: {}
-                }
-            };
-            await notificationUserDocument.create(newUserTemplate);
-            return notificationUserDocument;
-        };
-    });
-}
-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) {
-                        // re-apply exclusions to the updated configs
-                        const withExclusions = (0, firebase_1.applyExclusionsToNotificationUserNotificationBoxRecipientConfigs)({
-                            notificationUser,
-                            bc: updateTemplateBc,
-                            recalculateNs: false
-                        });
-                        updateTemplate.bc = withExclusions.bc;
-                        updateTemplate.b = updateTemplateBc.map((x) => x.nb);
-                    }
-                }
-                // if bc is being updated, then also update ns
-                if (updateTemplate.bc != null) {
-                    updateTemplate.ns = (0, firebase_1.calculateNsForNotificationUserNotificationBoxRecipientConfigs)(updateTemplate.bc);
-                }
-                await notificationUserDocumentInTransaction.update(updateTemplate);
-            });
-            return notificationUserDocument;
-        };
-    });
-}
-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 () => {
-        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, // mark as not removed
-                                        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;
-        };
-    });
-}
-function resyncAllNotificationUsersFactory(context) {
-    const { notificationUserCollection } = context;
-    const resyncNotificationUser = resyncNotificationUserFactory(context);
-    return async () => {
-        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;
-    };
-}
-function createNotificationSummaryFactory(context) {
-    const { firebaseServerActionTransformFunctionFactory, notificationSummaryCollection } = 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;
-        };
-    });
-}
-function updateNotificationSummaryFactory(context) {
-    const { firebaseServerActionTransformFunctionFactory } = 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;
-        };
-    });
-}
-function createNotificationBoxInTransactionFactory(context) {
-    const { notificationBoxCollection } = context;
-    return async (params, transaction) => {
-        const { now: inputNow, skipCreate } = params;
-        const now = inputNow ?? new Date();
-        const notificationBoxDocument = (0, firebase_1.loadNotificationBoxDocumentForReferencePair)(params, notificationBoxCollection.documentAccessorForTransaction(transaction));
-        const notificationBoxTemplate = {
-            m: notificationBoxDocument.notificationBoxRelatedModelKey,
-            o: (0, firebase_1.firestoreDummyKey)(), // set during initialization
-            r: [],
-            cat: now,
-            w: (0, date_1.yearWeekCode)(now),
-            s: true // requires initialization
-        };
-        if (!skipCreate) {
-            await notificationBoxDocument.create(notificationBoxTemplate);
-        }
-        return {
-            notificationBoxTemplate,
-            notificationBoxDocument
-        };
-    };
-}
-function createNotificationBoxFactory(context) {
-    const { firestoreContext, 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({ notificationBoxRelatedModelKey: model }, transaction);
-                return notificationBoxDocument;
-            });
-            return notificationBoxCollection.documentAccessor().loadDocumentFrom(result);
-        };
-    });
-}
-function updateNotificationBoxFactory({ firebaseServerActionTransformFunctionFactory }) {
-    return firebaseServerActionTransformFunctionFactory(firebase_1.UpdateNotificationBoxParams, async () => {
-        return async (notificationBoxDocument) => {
-            // does nothing currently.
-            return notificationBoxDocument;
-        };
-    });
-}
-function updateNotificationBoxRecipientExclusionInTransactionFactory(context) {
-    const { notificationBoxCollection, notificationUserCollection } = context;
-    return async (input, transaction) => {
-        const { params } = input;
-        const { uid: inputUid, i, setExclusion } = params;
-        const notificationBoxDocument = (0, firebase_1.loadNotificationBoxDocumentForReferencePair)(input, notificationBoxCollection.documentAccessorForTransaction(transaction));
-        let targetUid = inputUid;
-        let result = undefined;
-        if (setExclusion == null) {
-            throw new Error('setExclusion was undefined. Maybe you wanted to call updateNotificationBoxRecipientInTransactionFactory() instead?');
-        }
-        else if (!inputUid && i != null) {
-            // only load the notification box if targeting a recipient by index
-            const notificationBox = await notificationBoxDocument.snapshotData();
-            if (!notificationBox) {
-                throw (0, notification_error_1.notificationBoxExclusionTargetInvalidError)();
-            }
-            const targetRecipient = notificationBox.r.find((x) => x.i === i);
-            if (!targetRecipient || !targetRecipient.uid) {
-                throw (0, notification_error_1.notificationBoxExclusionTargetInvalidError)();
-            }
-            else {
-                targetUid = targetRecipient.uid;
-            }
-        }
-        if (!targetUid) {
-            throw (0, notification_error_1.notificationBoxExclusionTargetInvalidError)();
-        }
-        const notificationUserDocument = await notificationUserCollection.documentAccessorForTransaction(transaction).loadDocumentForId(targetUid);
-        const notificationUser = await notificationUserDocument.snapshotData();
-        if (notificationUser) {
-            // only update if the user exists
-            const targetExclusions = [notificationBoxDocument.id];
-            const { update: notificationUserUpdate } = (0, firebase_1.updateNotificationUserNotificationSendExclusions)({
-                notificationUser,
-                addExclusions: setExclusion ? targetExclusions : undefined,
-                removeExclusions: setExclusion ? undefined : targetExclusions
-            });
-            await notificationUserDocument.update(notificationUserUpdate);
-            result = {
-                notificationUserUpdate
-            };
-        }
-        return result;
-    };
-}
-function updateNotificationBoxRecipientInTransactionFactory(context) {
-    const { authService, notificationBoxCollection, notificationUserCollection } = context;
-    const createNotificationBoxInTransaction = createNotificationBoxInTransactionFactory(context);
-    return async (input, transaction) => {
-        const { params, allowCreateNotificationBoxIfItDoesNotExist, throwErrorIfNotificationBoxDoesNotExist } = input;
-        const { uid, i, insert, remove, configs: inputC, setExclusion } = params;
-        const findRecipientFn = (x) => (uid != null && x.uid === uid) || (i != null && x.i === i);
-        if (setExclusion != null) {
-            throw new Error('exclusion update must be processed by updateNotificationBoxRecipientExclusionInTransactionFactory() function.');
-        }
-        const notificationBoxDocument = (0, firebase_1.loadNotificationBoxDocumentForReferencePair)(input, notificationBoxCollection.documentAccessorForTransaction(transaction));
-        let notificationBox = await notificationBoxDocument.snapshotData();
-        let createNotificationBox = false;
-        let result = undefined;
-        if (!notificationBox) {
-            if (allowCreateNotificationBoxIfItDoesNotExist) {
-                const { notificationBoxTemplate } = await createNotificationBoxInTransaction({
-                    notificationBoxDocument,
-                    skipCreate: true // don't create since we still need to read things for the transaction
-                }, transaction);
-                notificationBox = notificationBoxTemplate;
-                createNotificationBox = true;
-            }
-            else if (throwErrorIfNotificationBoxDoesNotExist) {
-                throw (0, notification_error_1.notificationBoxDoesNotExist)();
-            }
-        }
-        if (notificationBox) {
-            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 has 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: [],
-                            x: [],
-                            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
-                }
-                const updatedNotificationBox = { ...notificationBox, r };
-                let notificationBoxWasCreated = false;
-                if (createNotificationBox) {
-                    await notificationBoxDocument.create(updatedNotificationBox);
-                    notificationBoxWasCreated = true;
-                }
-                else {
-                    await notificationBoxDocument.update({ r });
-                }
-                result = {
-                    updatedNotificationBox,
-                    notificationBoxWasCreated,
-                    notificationBoxDocument
-                };
-            }
-        }
-        return result;
-    };
-}
-function updateNotificationBoxRecipientFactory(context) {
-    const { firestoreContext, firebaseServerActionTransformFunctionFactory } = context;
-    const updateNotificationBoxRecipientInTransaction = updateNotificationBoxRecipientInTransactionFactory(context);
-    const updateNotificationBoxRecipientExclusionInTransaction = updateNotificationBoxRecipientExclusionInTransactionFactory(context);
-    return firebaseServerActionTransformFunctionFactory(firebase_1.UpdateNotificationBoxRecipientParams, async (params) => {
-        return async (notificationBoxDocument) => {
-            await firestoreContext.runTransaction(async (transaction) => {
-                if (params.setExclusion != null) {
-                    await updateNotificationBoxRecipientExclusionInTransaction({
-                        params,
-                        notificationBoxDocument
-                    }, transaction);
-                }
-                else {
-                    await updateNotificationBoxRecipientInTransaction({
-                        params,
-                        throwErrorIfNotificationBoxDoesNotExist: true,
-                        notificationBoxDocument
-                    }, transaction);
-                }
-            });
-            return notificationBoxDocument;
-        };
-    });
-}
-exports.UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_HOURS_DELAY = 8;
-exports.UNKNOWN_NOTIFICATION_TEMPLATE_TYPE_DELETE_AFTER_RETRY_ATTEMPTS = 1;
-exports.UNKNOWN_NOTIFICATION_TASK_TYPE_HOURS_DELAY = 8;
-exports.UNKNOWN_NOTIFICATION_TASK_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;
-/**
- * Minimum time in minutes that a notification task can be attempted again
- */
-exports.NOTIFICATION_TASK_MINIMUM_SET_AT_THROTTLE_TIME_MINUTES = 1;
-exports.NOTIFICATION_TASK_TYPE_MAX_SEND_ATTEMPTS = 5;
-exports.NOTIFICATION_TASK_TYPE_FAILURE_DELAY_HOURS = 3;
-exports.NOTIFICATION_TASK_TYPE_FAILURE_DELAY_MS = (0, date_fns_1.hoursToMilliseconds)(exports.NOTIFICATION_TASK_TYPE_FAILURE_DELAY_HOURS);
-function sendNotificationFactory(context) {
-    const { appNotificationTemplateTypeInfoRecordService, notificationSendService, notificationTaskService, 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 (inputNotificationDocument) => {
-            const now = new Date();
-            // Load the notification document outside of any potential context (transaction, etc.)
-            const notificationDocument = notificationCollectionGroup.documentAccessor().loadDocumentFrom(inputNotificationDocument);
-            const { nextSat, throttled, tryRun, isNotificationTask, notificationTaskHandler, notification, createdBox, notificationBoxNeedsInitialization, notificationBox, notificationBoxModelKey, deletedNotification, templateInstance, isConfiguredTemplateType, isKnownTemplateType, onlySendToExplicitlyEnabledRecipients, onlyTextExplicitlyEnabledRecipients } = 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([(0, firebase_1.getDocumentSnapshotData)(notificationBoxDocument), (0, firebase_1.getDocumentSnapshotData)(notificationDocumentInTransaction)]);
-                const model = (0, firebase_1.inferKeyFromTwoWayFlatFirestoreModelKey)(notificationBoxDocument.id);
-                const isNotificationTask = notification?.st === firebase_1.NotificationSendType.TASK_NOTIFICATION;
-                let tryRun = true;
-                let throttled = false;
-                let nextSat;
-                if (!notification) {
-                    tryRun = false;
-                }
-                else if (!ignoreSendAtThrottle) {
-                    tryRun = !(0, date_fns_1.isFuture)(notification.sat);
-                    if (!tryRun) {
-                        throttled = true;
-                    }
-                }
-                // always set nextSat if tryRun is true
-                if (tryRun) {
-                    if (isNotificationTask) {
-                        // can try to run the task again in 1 minute
-                        nextSat = (0, date_fns_1.addMinutes)(now, exports.NOTIFICATION_TASK_MINIMUM_SET_AT_THROTTLE_TIME_MINUTES);
-                    }
-                    else {
-                        // update the next send type of non-tasks to try being sent again in 10 minutes, if they fail
-                        nextSat = (0, date_fns_1.addMinutes)(now, 10);
-                    }
-                }
-                let createdBox = false;
-                let deletedNotification = false;
-                let notificationBoxNeedsInitialization = false;
-                let isKnownTemplateType;
-                let isConfiguredTemplateType;
-                let onlySendToExplicitlyEnabledRecipients;
-                let onlyTextExplicitlyEnabledRecipients;
-                let templateInstance;
-                let notificationTaskHandler;
-                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 task/template type
-                     } = notification.n;
-                    if (isNotificationTask) {
-                        notificationTaskHandler = notificationTaskService.taskHandlerForNotificationTaskType(t);
-                        if (notificationTaskHandler) {
-                            if (notification.a >= exports.NOTIFICATION_TASK_TYPE_MAX_SEND_ATTEMPTS) {
-                                tryRun = false;
-                                console.warn(`Configured notification task of type "${t}" has reached the delete threshhold after being attempted ${notification.a} times. Deleting notification task.`);
-                                await deleteNotification();
-                            }
-                        }
-                        else {
-                            tryRun = false;
-                            const delay = exports.UNKNOWN_NOTIFICATION_TASK_TYPE_HOURS_DELAY;
-                            if (notification.a < exports.UNKNOWN_NOTIFICATION_TASK_TYPE_DELETE_AFTER_RETRY_ATTEMPTS) {
-                                console.warn(`Notification task type of "${t}" was found in a Notification but has no handler. Action is being delayed by ${delay} hours.`);
-                                nextSat = (0, date_fns_1.addHours)(now, delay);
-                            }
-                            else {
-                                console.warn(`Notification task type of "${t}" was found in a Notification but has no handler. Action is being deleted.`);
-                                // delete the notification
-                                await deleteNotification();
-                            }
-                        }
-                    }
-                    else {
-                        templateInstance = notificationTemplateService.templateInstanceForType(t);
-                        isConfiguredTemplateType = templateInstance.isConfiguredType;
-                        const templateTypeInfo = appNotificationTemplateTypeInfoRecordService.appNotificationTemplateTypeInfoRecord[t];
-                        isKnownTemplateType = templateTypeInfo != null;
-                        onlySendToExplicitlyEnabledRecipients = notification.ois ?? templateTypeInfo?.onlySendToExplicitlyEnabledRecipients;
-                        onlyTextExplicitlyEnabledRecipients = notification.ots ?? templateTypeInfo?.onlyTextExplicitlyEnabledRecipients;
-                        if (!isConfiguredTemplateType) {
-                            // log the issue that an notification with an unconfigured type was queued
-                            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}" (${templateTypeInfo.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)(now, 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({ notificationBoxDocument }, transaction);
-                                    notificationBox = (0, firebase_1.setIdAndKeyFromKeyIdRefOnDocumentData)(notificationBoxTemplate, notificationBoxDocument);
-                                    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)(now, 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.
-                    }
-                    // check if it was just deleted
-                    if (!deletedNotification) {
-                        const a = isNotificationTask && tryRun ? notification.a : notification.a + 1; // do not update a notification task's attempt count here, unless tryRun fails
-                        // NOTE: It is important to update sat so the notification task queue running doesn't get stuck in a query loop by notifications/tasks that have a sat value that is in the past, but was just run.
-                        await notificationDocumentInTransaction.update({ sat: nextSat, a });
-                    }
-                }
-                return {
-                    nextSat,
-                    throttled,
-                    isNotificationTask,
-                    deletedNotification,
-                    createdBox,
-                    notificationBoxModelKey: model,
-                    notificationBoxNeedsInitialization,
-                    notificationBox,
-                    notification,
-                    templateInstance,
-                    isKnownTemplateType,
-                    notificationTaskHandler,
-                    isConfiguredTemplateType,
-                    tryRun,
-                    onlySendToExplicitlyEnabledRecipients,
-                    onlyTextExplicitlyEnabledRecipients
-                };
-            });
-            let success = false;
-            let isUniqueNotificationTask = false;
-            let uniqueNotificationTaskConflict = false;
-            let sendEmailsResult;
-            let sendTextsResult;
-            let sendNotificationSummaryResult;
-            let loadMessageFunctionFailure = false;
-            let buildMessageFailure = false;
-            let notificationMarkedDone = false;
-            let notificationTaskCompletionType;
-            let notificationTaskPartsRunCount = 0;
-            let notificationTaskLoopingProtectionTriggered;
-            let onSendAttemptedResult;
-            let onSendSuccessResult;
-            const notificationTemplateType = templateInstance?.type;
-            if (isNotificationTask) {
-                await handleNotificationTask();
-            }
-            else {
-                await handleNormalNotification();
-            }
-            async function _runNotificationTaskNextPart(input) {
-                const { notification, notificationTaskHandler, previouslyCompleteSubTasks } = input;
-                const { n: item, cat, ut } = notification;
-                let tryRunNextPart = false;
-                let partNotificationTaskCompletionType;
-                let partNotificationMarkedDone = false;
-                let partTprReversal = false;
-                let partSuccess = false;
-                let nextCompleteSubTasks;
-                const unique = ut ?? false;
-                const notificationTask = {
-                    notificationDocument,
-                    totalSendAttempts: notification.a,
-                    currentCheckpointSendAttempts: notification.at ?? 0,
-                    taskType: item.t,
-                    item,
-                    data: item.d,
-                    checkpoints: notification.tpr,
-                    createdAt: cat,
-                    unique
-                };
-                // calculate results
-                const notificationTemplate = {};
-                // perform the task
-                try {
-                    const handleTaskResult = await notificationTaskHandler.handleNotificationTask(notificationTask);
-                    const { completion, updateMetadata, delayUntil, canRunNextCheckpoint, allCompletedSubTasks } = handleTaskResult;
-                    partNotificationTaskCompletionType = completion;
-                    partSuccess = true;
-                    switch (completion) {
-                        case true:
-                            notificationTemplate.d = true; // mark as done
-                            break;
-                        case false:
-                            // failed
-                            notificationTemplate.a = notification.a + 1; // increase attempts count
-                            notificationTemplate.at = (notification.at ?? 0) + 1; // increase checkpoint attempts count
-                            // remove any completions, if applicable
-                            notificationTemplate.tpr = (0, notification_task_service_util_1.removeFromCompletionsArrayWithTaskResult)(notification.tpr, handleTaskResult);
-                            partSuccess = false;
-                            break;
-                        default:
-                            // default case called if not true or false, which implies either a delay or partial completion
-                            // update the checkpoint attempts count
-                            if (Array.isArray(completion) && completion.length === 0) {
-                                notificationTemplate.at = (notification.at ?? 0) + 1; // increase checkpoint attempt/delays count
-                                tryRunNextPart = canRunNextCheckpoint === true && allCompletedSubTasks != null && delayUntil == null; // can only run the next part if subtasks were returned and there is no delay
-                            }
-                            else {
-                                tryRunNextPart = canRunNextCheckpoint === true && delayUntil == null; // can try the next part if there is no delayUntil and canRunNextCheckpoint is true
-                                notificationTemplate.at = 0; // reset checkpoint attempt/delay count
-                            }
-                            // add the checkpoint to the notification
-                            notificationTemplate.tpr = [
-                                ...(0, notification_task_service_util_1.removeFromCompletionsArrayWithTaskResult)(notification.tpr, handleTaskResult), // remove any completions, if applicable
-                                ...(0, util_1.asArray)(completion)
-                            ];
-                            // calculate the updated notification item
-                            notificationTemplate.n = {
-                                ...notification.n,
-                                d: {
-                                    ...notification.n.d,
-                                    ...(updateMetadata ? (0, util_1.filterOnlyUndefinedValues)(updateMetadata) : undefined) // ignore any undefined values
-                                }
-                            };
-                            // can only run the next part if the tpr has changed, and the number of checkpoints completed has increased
-                            // if the tpr has not changed, then it is also considered a reversal
-                            if (tryRunNextPart) {
-                                const tprChanged = !(0, util_1.iterablesAreSetEquivalent)(notification.tpr, notificationTemplate.tpr);
-                                partTprReversal = !tprChanged || (tprChanged && notificationTemplate.tpr.length <= notification.tpr.length);
-                                if (allCompletedSubTasks != null) {
-                                    switch (allCompletedSubTasks) {
-                                        case true:
-                                        case false:
-                                            // only run if there is no tpr reversal flagged
-                                            tryRunNextPart = !partTprReversal;
-                                            break;
-                                        default:
-                                            // check subtask tpr changes
-                                            nextCompleteSubTasks = (0, util_1.asArray)(allCompletedSubTasks);
-                                            const subtaskTprChanged = !(0, util_1.iterablesAreSetEquivalent)(previouslyCompleteSubTasks, nextCompleteSubTasks);
-                                            partTprReversal = !subtaskTprChanged || (subtaskTprChanged && nextCompleteSubTasks.length <= previouslyCompleteSubTasks.length);
-                                            break;
-                                    }
-                                }
-                            }
-                            break;
-                    }
-                    // do not update sat if the task is complete
-                    if (completion !== true && delayUntil != null) {
-                        // must be at least 20 seconds into the future from now, and/or the nextSat time to avoid parallel runs
-                        const minimumNextSatTime = (0, date_fns_1.addSeconds)(new Date(), 20);
-                        notificationTemplate.sat = (0, date_1.findMaxDate)([(0, util_1.dateOrMillisecondsToDate)(delayUntil, now), nextSat, minimumNextSatTime]) ?? minimumNextSatTime;
-                    }
-                    partNotificationMarkedDone = notificationTemplate.d === true;
-                }
-                catch (e) {
-                    console.error(`Failed handling task for notification "${notification.key}" with type "${notificationTask.taskType}": `, e);
-                    notificationTemplate.a = notification.a + 1; // increase attempts count
-                    notificationTemplate.sat = (0, util_1.dateOrMillisecondsToDate)(exports.NOTIFICATION_TASK_TYPE_FAILURE_DELAY_MS, now);
-                    partSuccess = false;
-                }
-                // notification tasks are read
-                let saveTaskResult = true;
-                if (unique) {
-                    isUniqueNotificationTask = true;
-                    const latestNotification = await notificationDocument.snapshotData();
-                    if (!latestNotification || !(0, date_1.isSameDate)(latestNotification.cat, notification.cat)) {
-                        saveTaskResult = false;
-                        uniqueNotificationTaskConflict = true;
-                    }
-                }
-                if (saveTaskResult) {
-                    await notificationDocument.update(notificationTemplate);
-                }
-                return {
-                    tryRunNextPart,
-                    partNotificationMarkedDone,
-                    partNotificationTaskCompletionType,
-                    partTprReversal,
-                    nextCompleteSubTasks,
-                    partSuccess
-                };
-            }
-            /**
-             * Notification task handling.
-             *
-             * Notification takss can have multiple async but sequential parts.
-             *
-             * Some of these parts may be able to be run immediately one after the other, instead of waiting for
-             * another sendNotification() to complete on it.
-             */
-            async function handleNotificationTask() {
-                const MAX_NOTIFICATION_TASK_PARTS_RUN_ALLOWED = 5;
-                if (tryRun && notification != null && notificationTaskHandler) {
-                    let currentNotification = notification;
-                    let previouslyCompleteSubTasks = [];
-                    notificationTaskLoopingProtectionTriggered = false;
-                    notificationTaskPartsRunCount = 0;
-                    while (notificationTaskPartsRunCount < MAX_NOTIFICATION_TASK_PARTS_RUN_ALLOWED) {
-                        notificationTaskPartsRunCount += 1;
-                        const result = await _runNotificationTaskNextPart({
-                            notification: currentNotification,
-                            notificationTaskHandler,
-                            previouslyCompleteSubTasks
-                        });
-                        notificationTaskCompletionType = result.partNotificationTaskCompletionType;
-                        previouslyCompleteSubTasks = result.nextCompleteSubTasks ?? [];
-                        success = result.partSuccess;
-                        const tryRunNextPart = result.partSuccess && result.tryRunNextPart && !notificationTaskLoopingProtectionTriggered;
-                        notificationTaskLoopingProtectionTriggered = notificationTaskLoopingProtectionTriggered || result.partTprReversal; // update the flag if the TPR has been reversed
-                        if (tryRunNextPart) {
-                            const updatedNotificationData = await notificationDocument.snapshotData();
-                            if (updatedNotificationData) {
-                                currentNotification = (0, firebase_1.setIdAndKeyFromKeyIdRefOnDocumentData)(updatedNotificationData, notificationDocument);
-                            }
-                            else {
-                                break; // notification is unavailable now
-                            }
-                        }
-                        else {
-                            break; // escape the loop
-                        }
-                    }
-                }
-            }
-            /**
-             * Handles a normal (non-task) notification.
-             */
-            async function handleNormalNotification() {
-                // 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) {
-                            function filterOutNoContentNotificationMessages(messages) {
-                                return messages.filter((x) => !x.flag);
-                            }
-                            // expand recipients
-                            const { emails: emailRecipients, texts: textRecipients, notificationSummaries: notificationSummaryRecipients } = await (0, notification_util_1.expandNotificationRecipients)({
-                                notification,
-                                notificationBox,
-                                authService,
-                                notificationUserAccessor,
-                                globalRecipients: messageFunction.globalRecipients,
-                                onlySendToExplicitlyEnabledRecipients,
-                                onlyTextExplicitlyEnabledRecipients,
-                                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))
-                                    .then(filterOutNoContentNotificationMessages)
-                                    .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))
-                                    .then(filterOutNoContentNotificationMessages)
-                                    .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 } = 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))
-                                    .then(filterOutNoContentNotificationMessages)
-                                    .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;
-                            const callbackDetails = {
-                                success,
-                                updatedSendFlags: notificationTemplate,
-                                sendEmailsResult,
-                                sendTextsResult,
-                                sendNotificationSummaryResult
-                            };
-                            const { onSendAttempted, onSendSuccess } = messageFunction;
-                            // call onSendAttempted, if one is configured
-                            if (onSendAttempted) {
-                                onSendAttemptedResult = await (0, util_1.asPromise)(onSendAttempted(callbackDetails))
-                                    .then((value) => {
-                                    return { value };
-                                })
-                                    .catch((e) => {
-                                    console.warn(`Caught exception while calling onSendAttempted for notification "${notification.id}" with type "${notificationTemplateType}": `, e);
-                                    return { error: e };
-                                });
-                            }
-                            // call onSendSuccess, if one is configured
-                            if (notificationMarkedDone && onSendSuccess) {
-                                onSendSuccessResult = await (0, util_1.asPromise)(onSendSuccess(callbackDetails))
-                                    .then((value) => {
-                                    return { value };
-                                })
-                                    .catch((e) => {
-                                    console.warn(`Caught exception while calling onSendSuccess for notification "${notification.id}" with type "${notificationTemplateType}": `, e);
-                                    return { error: e };
-                                });
-                            }
-                        }
-                    }
-                    else {
-                        switch (notification.st) {
-                            case firebase_1.NotificationSendType.SEND_IF_BOX_EXISTS:
-                                // deleted successfully
-                                success = deletedNotification;
-                                break;
-                        }
-                    }
-                }
-            }
-            const result = {
-                notificationTemplateType,
-                isKnownTemplateType,
-                isNotificationTask,
-                isUniqueNotificationTask,
-                uniqueNotificationTaskConflict,
-                isConfiguredTemplateType,
-                throttled,
-                exists: notification != null,
-                boxExists: notificationBox != null,
-                notificationTaskPartsRunCount,
-                notificationTaskLoopingProtectionTriggered,
-                notificationBoxNeedsInitialization,
-                notificationTaskCompletionType,
-                createdBox,
-                deletedNotification,
-                notificationMarkedDone,
-                tryRun,
-                success,
-                sendEmailsResult,
-                sendTextsResult,
-                sendNotificationSummaryResult,
-                loadMessageFunctionFailure,
-                buildMessageFailure,
-                onSendAttemptedResult,
-                onSendSuccessResult
-            };
-            return result;
-        };
-    });
-}
-exports.SEND_QUEUE_NOTIFICATIONS_TASK_EXCESS_THRESHOLD = 5000;
-function sendQueuedNotificationsFactory(context) {
-    const { firebaseServerActionTransformFunctionFactory, notificationCollectionGroup } = context;
-    const sendNotification = sendNotificationFactory(context);
-    return firebaseServerActionTransformFunctionFactory(firebase_1.SendQueuedNotificationsParams, async (params) => {
-        const { maxSendNotificationLoops } = params;
-        const maxLoops = maxSendNotificationLoops ?? Number.MAX_SAFE_INTEGER;
-        const sendNotificationLoopsTaskExcessThreshold = params.sendNotificationLoopsTaskExcessThreshold ?? exports.SEND_QUEUE_NOTIFICATIONS_TASK_EXCESS_THRESHOLD;
-        return async (input) => {
-            const maxParallelTasks = input?.maxParellelSendTasks ?? params.maxParellelSendTasks ?? 5;
-            const onSendNotificationResult = input?.onSendNotificationResult ?? (0, util_1.mapIdentityFunction)();
-            let notificationLoopCount = 0;
-            let notificationBoxesCreated = 0;
-            let notificationsDeleted = 0;
-            let notificationTasksVisited = 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);
-            let excessLoopsDetected = false;
-            const sendQueuedNotifications = async () => {
-                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);
-                    onSendNotificationResult(result, notificationDocument);
-                    return result;
-                }, {
-                    maxParallelTasks
-                });
-                return result;
-            };
-            // iterate through all notification items that need to be synced
-            // eslint-disable-next-line no-constant-condition
-            while (notificationLoopCount < maxLoops) {
-                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.isNotificationTask) {
-                        notificationTasksVisited += 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;
-                notificationLoopCount += 1;
-                if (!found) {
-                    break;
-                }
-                else if (!excessLoopsDetected && notificationLoopCount > sendNotificationLoopsTaskExcessThreshold) {
-                    excessLoopsDetected = true;
-                    console.error(`sendQueuedNotifications(EXCESS_LOOPS_DETECTED): Exceeded send notification loops task excess threshold of ${sendNotificationLoopsTaskExcessThreshold}.`);
-                    // continue the loops
-                }
-            }
-            const result = {
-                excessLoopsDetected,
-                notificationLoopCount,
-                notificationBoxesCreated,
-                notificationsDeleted,
-                notificationTasksVisited,
-                notificationsVisited,
-                notificationsSucceeded,
-                notificationsDelayed,
-                notificationsFailed,
-                sendEmailsResult,
-                sendTextsResult,
-                sendNotificationSummaryResult
-            };
-            return result;
-        };
-    });
-}
-function cleanupSentNotificationsFactory(context) {
-    const { firestoreContext, firebaseServerActionTransformFunctionFactory, notificationCollectionGroup, notificationBoxCollection, notificationWeekCollectionFactory } = context;
-    return firebaseServerActionTransformFunctionFactory(firebase_1.CleanupSentNotificationsParams, async () => {
-        return async () => {
-            let notificationBoxesUpdatesCount = 0;
-            let notificationsDeleted = 0;
-            const notificationTasksDeletedCount = 0;
-            let notificationWeeksCreated = 0;
-            let notificationWeeksUpdated = 0;
-            // iterate through all Notification items that need to be cleaned up
-            // eslint-disable-next-line no-constant-condition
-            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 { included: taskPairsWithDataAndMarkedDeleted, excluded: normalPairsWithDataAndMarkedDeleted } = (0, util_1.separateValues)(allPairsWithDataAndMarkedDeleted, (x) => x.data?.st === firebase_1.NotificationSendType.TASK_NOTIFICATION);
-                    const pairsGroupedByWeek = Array.from((0, util_1.makeValuesGroupMap)(normalPairsWithDataAndMarkedDeleted, (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
-                            };
-                        });
-                    });
-                    // delete all the task notifications
-                    const writeBatch = firestoreContext.batch();
-                    const writeBatchAccessor = notificationCollectionGroup.documentAccessorForTransaction(writeBatch);
-                    await Promise.all(taskPairsWithDataAndMarkedDeleted.map((x) => writeBatchAccessor.loadDocumentFrom(x.document).accessor.delete()));
-                    await writeBatch.commit();
-                    let weeksCreated = 0;
-                    let weeksUpdated = 0;
-                    const tasksDeleted = taskPairsWithDataAndMarkedDeleted.length;
-                    notificationWeekResults.results.forEach((x) => {
-                        if (x[1].created) {
-                            weeksCreated += 1;
-                        }
-                        else {
-                            weeksUpdated += 1;
-                        }
-                    });
-                    const result = {
-                        weeksCreated,
-                        weeksUpdated,
-                        itemsDeleted: allPairsWithDataAndMarkedDeleted.length,
-                        tasksDeleted
-                    };
-                    return result;
-                }, {
-                    maxParallelTasks: 10
-                });
-                return result;
-            }
-            const result = {
-                notificationBoxesUpdatesCount,
-                notificationTasksDeletedCount,
-                notificationsDeleted,
-                notificationWeeksCreated,
-                notificationWeeksUpdated
-            };
-            return result;
-        };
-    });
-}
-//# sourceMappingURL=notification.action.service.js.map