@dereekb/firebase-server 12.5.10 → 12.6.0

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

@@ -8,10 +8,18 @@ exports._initializeStorageFileFromUploadFileFactory = _initializeStorageFileFrom
 exports.initializeStorageFileFromUploadFactory = initializeStorageFileFromUploadFactory;
 exports.updateStorageFileFactory = updateStorageFileFactory;
 exports.processAllQueuedStorageFilesFactory = processAllQueuedStorageFilesFactory;
+exports._processStorageFileInTransactionFactory = _processStorageFileInTransactionFactory;
 exports.processStorageFileFactory = processStorageFileFactory;
 exports.deleteAllQueuedStorageFilesFactory = deleteAllQueuedStorageFilesFactory;
 exports.deleteStorageFileFactory = deleteStorageFileFactory;
 exports.downloadStorageFileFactory = downloadStorageFileFactory;
+exports.createStorageFileGroupInTransactionFactory = createStorageFileGroupInTransactionFactory;
+exports.createStorageFileGroupFactory = createStorageFileGroupFactory;
+exports._syncStorageFileWithGroupsInTransactionFactory = _syncStorageFileWithGroupsInTransactionFactory;
+exports.syncStorageFileWithGroupsFactory = syncStorageFileWithGroupsFactory;
+exports.syncAllFlaggedStorageFilesWithGroupsFactory = syncAllFlaggedStorageFilesWithGroupsFactory;
+exports.regenerateStorageFileGroupContentFactory = regenerateStorageFileGroupContentFactory;
+exports.regenerateAllFlaggedStorageFileGroupsContentFactory = regenerateAllFlaggedStorageFileGroupsContentFactory;
 const firebase_1 = require("@dereekb/firebase");
 const firebase_server_1 = require("@dereekb/firebase-server");
 const storagefile_error_1 = require("./storagefile.error");
@@ -39,7 +47,12 @@ function storageFileServerActions(context) {
         processStorageFile: processStorageFileFactory(context),
         deleteAllQueuedStorageFiles: deleteAllQueuedStorageFilesFactory(context),
         deleteStorageFile: deleteStorageFileFactory(context),
-        downloadStorageFile: downloadStorageFileFactory(context)
+        downloadStorageFile: downloadStorageFileFactory(context),
+        createStorageFileGroup: createStorageFileGroupFactory(context),
+        syncStorageFileWithGroups: syncStorageFileWithGroupsFactory(context),
+        syncAllFlaggedStorageFilesWithGroups: syncAllFlaggedStorageFilesWithGroupsFactory(context),
+        regenerateStorageFileGroupContent: regenerateStorageFileGroupContentFactory(context),
+        regenerateAllFlaggedStorageFileGroupsContent: regenerateAllFlaggedStorageFileGroupsContentFactory(context)
     };
 }
 // MARK: Actions
@@ -216,11 +229,15 @@ function processAllQueuedStorageFilesFactory(context) {
             let storageFilesVisited = 0;
             let storageFilesProcessStarted = 0;
             let storageFilesFailedStarting = 0;
+            const proceessStorageFileParams = {
+                key: (0, firebase_1.firestoreDummyKey)()
+            };
+            const processStorageFileInstance = await processStorageFile(proceessStorageFileParams);
             await (0, firebase_1.iterateFirestoreDocumentSnapshotPairs)({
                 documentAccessor: storageFileCollection.documentAccessor(),
                 iterateSnapshotPair: async (snapshotPair) => {
                     storageFilesVisited++;
-                    const processStorageFileResult = await processStorageFile(snapshotPair.document).catch(() => null);
+                    const processStorageFileResult = await processStorageFileInstance(snapshotPair.document).catch(() => null);
                     if (processStorageFileResult) {
                         storageFilesProcessStarted++;
                     }
@@ -244,86 +261,115 @@ function processAllQueuedStorageFilesFactory(context) {
         };
     });
 }
+function _processStorageFileInTransactionFactory(context) {
+    const { storageFileCollection, notificationCollectionGroup } = context;
+    return async (input, transaction) => {
+        const { storageFileDocument, storageFile: inputStorageFile, params, expediteInstance } = input;
+        const { checkRetryProcessing, forceRestartProcessing, processAgainIfSuccessful } = params ?? {};
+        const storageFileDocumentInTransaction = storageFileCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(storageFileDocument);
+        const storageFile = inputStorageFile ?? (await (0, firebase_server_1.assertSnapshotData)(storageFileDocumentInTransaction));
+        async function beginProcessing(overrideExistingTask) {
+            const state = storageFile.fs;
+            // check the storageFile is in the OK state
+            if (state !== firebase_1.StorageFileState.OK) {
+                throw (0, storagefile_error_1.storageFileProcessingNotAllowedForInvalidStateError)();
+            }
+            const createNotificationTaskResult = await (0, firebase_1.createNotificationDocument)({
+                context,
+                transaction,
+                template: (0, firebase_1.storageFileProcessingNotificationTaskTemplate)({
+                    storageFileDocument,
+                    overrideExistingTask
+                })
+            });
+            await storageFileDocumentInTransaction.update({
+                ps: firebase_1.StorageFileProcessingState.PROCESSING,
+                pat: new Date(), // set new processing start date
+                pcat: null, // clear processing completion date
+                pn: createNotificationTaskResult.notificationDocument.key
+            });
+            expediteInstance?.enqueueCreateResult(createNotificationTaskResult);
+        }
+        switch (storageFile.ps) {
+            case firebase_1.StorageFileProcessingState.INIT_OR_NONE:
+                // queue up for processing, unless it has no purpose
+                if (!storageFile.p) {
+                    throw (0, storagefile_error_1.storageFileProcessingNotAvailableForTypeError)();
+                }
+                else {
+                    await beginProcessing(false);
+                }
+                break;
+            case firebase_1.StorageFileProcessingState.QUEUED_FOR_PROCESSING:
+                // begin processing
+                await beginProcessing(false);
+                break;
+            case firebase_1.StorageFileProcessingState.PROCESSING:
+                // check if the processing task is still running
+                const shouldCheckProcessing = !(0, util_1.isThrottled)(firebase_1.STORAGE_FILE_PROCESSING_STUCK_THROTTLE_CHECK_MS, storageFile.pat);
+                if (!storageFile.pn) {
+                    await beginProcessing(true); // if no processing task is set, restart processing to recover from the broken state
+                }
+                else {
+                    const { pn } = storageFile;
+                    const notificationDocument = notificationCollectionGroup.documentAccessorForTransaction(transaction).loadDocumentForKey(pn);
+                    if (checkRetryProcessing || shouldCheckProcessing) {
+                        const notification = await notificationDocument.snapshotData();
+                        if (!notification) {
+                            // the notification document is missing. Re-begin processing
+                            await beginProcessing(true);
+                        }
+                        else if (notification.d || forceRestartProcessing) {
+                            // if the notification is somehow in the done state but the StorageFile never got notified in the same transaction, requeue.
+                            await beginProcessing(true);
+                        }
+                        // NOTE: We could look at the state of the notification task more, but at this point the task is probably still valid and still running,
+                        // so we can only wait on it. In general if the task still exists and is not yet done, then we should wait on it as the
+                        // task running system should complete eventually by design.
+                    }
+                    else if (expediteInstance) {
+                        // enqueue the existing notification to be run in the expedite instance
+                        expediteInstance.enqueue(notificationDocument);
+                    }
+                }
+                break;
+            case firebase_1.StorageFileProcessingState.DO_NOT_PROCESS:
+                throw (0, storagefile_error_1.storageFileProcessingNotQueuedForProcessingError)();
+            case firebase_1.StorageFileProcessingState.SUCCESS:
+                if (forceRestartProcessing || processAgainIfSuccessful) {
+                    await beginProcessing(true);
+                }
+                else {
+                    throw (0, storagefile_error_1.storageFileAlreadyProcessedError)();
+                }
+                break;
+        }
+    };
+}
 function processStorageFileFactory(context) {
-    const { storageFileCollection, notificationCollectionGroup, firestoreContext, notificationExpediteService, firebaseServerActionTransformFunctionFactory } = context;
+    const { firestoreContext, notificationExpediteService, firebaseServerActionTransformFunctionFactory } = context;
+    const processStorageFileInTransaction = _processStorageFileInTransactionFactory(context);
     return firebaseServerActionTransformFunctionFactory(firebase_1.ProcessStorageFileParams, async (params) => {
-        const { runImmediately, checkRetryProcessing, forceRestartProcessing } = params;
+        const { runImmediately } = params;
         return async (storageFileDocument) => {
-            const result = {};
             const expediteInstance = notificationExpediteService.expediteInstance();
             await firestoreContext.runTransaction(async (transaction) => {
                 expediteInstance.initialize();
-                const storageFileDocumentInTransaction = await storageFileCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(storageFileDocument);
-                const storageFile = await (0, firebase_server_1.assertSnapshotData)(storageFileDocumentInTransaction);
-                async function beginProcessing(overrideExistingTask) {
-                    const state = storageFile.fs;
-                    // check the storageFile is in the OK state
-                    if (state !== firebase_1.StorageFileState.OK) {
-                        throw (0, storagefile_error_1.storageFileProcessingNotAllowedForInvalidStateError)();
-                    }
-                    const createNotificationTaskResult = await (0, firebase_1.createNotificationDocument)({
-                        context,
-                        transaction,
-                        template: (0, firebase_1.storageFileProcessingNotificationTaskTemplate)({
-                            storageFileDocument,
-                            overrideExistingTask
-                        })
-                    });
-                    await storageFileDocumentInTransaction.update({
-                        ps: firebase_1.StorageFileProcessingState.PROCESSING,
-                        pat: new Date(), // set new processing start date
-                        pcat: null, // clear processing completion date
-                        pn: createNotificationTaskResult.notificationDocument.key
-                    });
-                    expediteInstance.enqueueCreateResult(createNotificationTaskResult);
-                }
-                switch (storageFile.ps) {
-                    case firebase_1.StorageFileProcessingState.INIT_OR_NONE:
-                        // queue up for processing, unless it has no purpose
-                        if (!storageFile.p) {
-                            throw (0, storagefile_error_1.storageFileProcessingNotAvailableForTypeError)();
-                        }
-                        else {
-                            await beginProcessing(false);
-                        }
-                        break;
-                    case firebase_1.StorageFileProcessingState.QUEUED_FOR_PROCESSING:
-                        // begin processing
-                        await beginProcessing(false);
-                        break;
-                    case firebase_1.StorageFileProcessingState.PROCESSING:
-                        // check if the processing task is still running
-                        const shouldCheckProcessing = !(0, util_1.isThrottled)(firebase_1.STORAGE_FILE_PROCESSING_STUCK_THROTTLE_CHECK_MS, storageFile.pat);
-                        if (!storageFile.pn) {
-                            await beginProcessing(true); // if no processing task is set, restart processing to recover from the broken state
-                        }
-                        else if (checkRetryProcessing || shouldCheckProcessing) {
-                            const { pn } = storageFile;
-                            const notificationDocument = notificationCollectionGroup.documentAccessorForTransaction(transaction).loadDocumentForKey(pn);
-                            const notification = await notificationDocument.snapshotData();
-                            if (!notification) {
-                                // the notification document is missing. Re-begin processing
-                                await beginProcessing(true);
-                            }
-                            else if (notification.d || forceRestartProcessing) {
-                                // if the notification is somehow in the done state but the StorageFile never got notified in the same transaction, requeue.
-                                await beginProcessing(true);
-                            }
-                            // NOTE: We could look at the state of the notification task more, but at this point the task is probably still valid and still running,
-                            // so we can only wait on it. In general if the task still exists and is not yet done, then we should wait on it as the
-                            // task running system should complete eventually by design.
-                        }
-                        break;
-                    case firebase_1.StorageFileProcessingState.DO_NOT_PROCESS:
-                        throw (0, storagefile_error_1.storageFileProcessingNotQueuedForProcessingError)();
-                    case firebase_1.StorageFileProcessingState.SUCCESS:
-                        throw (0, storagefile_error_1.storageFileAlreadySuccessfullyProcessedError)();
-                }
+                await processStorageFileInTransaction({
+                    storageFileDocument,
+                    params,
+                    expediteInstance
+                }, transaction);
             });
+            let expediteResult = null;
             // expedite the task if requested
             if (runImmediately) {
-                await expediteInstance.send();
+                expediteResult = await expediteInstance.send().then((x) => x[0]);
             }
+            const result = {
+                runImmediately: runImmediately ?? false,
+                expediteResult
+            };
             return result;
         };
     });
@@ -371,52 +417,68 @@ function deleteAllQueuedStorageFilesFactory(context) {
     });
 }
 function deleteStorageFileFactory(context) {
-    const { storageService, storageFileCollection, firebaseServerActionTransformFunctionFactory } = context;
+    const { firestoreContext, storageService, storageFileCollection, firebaseServerActionTransformFunctionFactory } = context;
+    const syncStorageFileWithGroupsInTransaction = _syncStorageFileWithGroupsInTransactionFactory(context);
     return firebaseServerActionTransformFunctionFactory(firebase_1.DeleteStorageFileParams, async (params) => {
         const { force } = params;
         return async (inputStorageFileDocument) => {
-            const storageFileDocument = await storageFileCollection.documentAccessor().loadDocumentFrom(inputStorageFileDocument);
-            const storageFile = await (0, firebase_server_1.assertSnapshotData)(storageFileDocument);
-            const fileAccessor = storageService.file(storageFile);
-            if (!force) {
-                if (!storageFile.sdat) {
-                    throw (0, storagefile_error_1.storageFileNotFlaggedForDeletionError)();
-                }
-                else if (!(0, util_1.isPast)(storageFile.sdat)) {
-                    throw (0, storagefile_error_1.storageFileCannotBeDeletedYetError)();
+            await firestoreContext.runTransaction(async (transaction) => {
+                const storageFileDocument = await storageFileCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(inputStorageFileDocument);
+                const storageFile = await (0, firebase_server_1.assertSnapshotData)(storageFileDocument);
+                const fileAccessor = storageService.file(storageFile);
+                if (!force) {
+                    if (!storageFile.sdat) {
+                        throw (0, storagefile_error_1.storageFileNotFlaggedForDeletionError)();
+                    }
+                    else if (!(0, util_1.isPast)(storageFile.sdat)) {
+                        throw (0, storagefile_error_1.storageFileCannotBeDeletedYetError)();
+                    }
                 }
-            }
-            // delete the file
-            await fileAccessor.delete().catch(() => null);
-            // delete the document
-            await storageFileDocument.accessor.delete();
+                // remove the storage file from any groups
+                await syncStorageFileWithGroupsInTransaction({ storageFileDocument, storageFile, force: true, removeAllStorageFileGroups: true }, transaction);
+                // delete the file
+                await fileAccessor.delete().catch(() => null);
+                // delete the document
+                await storageFileDocument.accessor.delete();
+            });
         };
     });
 }
 function downloadStorageFileFactory(context) {
-    const { storageService, firebaseServerActionTransformFunctionFactory } = context;
+    const { storageService, firebaseServerActionTransformFunctionFactory, storageFileCollection } = context;
     return firebaseServerActionTransformFunctionFactory(firebase_1.DownloadStorageFileParams, async (params) => {
-        const { asAdmin, expiresAt, expiresIn, responseDisposition, responseContentType } = params;
+        const { key: targetStorageFileDocumentKey, asAdmin, expiresAt, expiresIn: inputExpiresIn, responseDisposition, responseContentType } = params;
         return async (storageFileDocument) => {
+            // if the StorageFileDocument was not provided, set it from the target key
+            if (!storageFileDocument) {
+                storageFileDocument = storageFileCollection.documentAccessor().loadDocumentForKey(targetStorageFileDocumentKey);
+            }
             const storageFile = await (0, firebase_server_1.assertSnapshotData)(storageFileDocument);
             const fileAccessor = storageService.file(storageFile);
             let result;
             if (fileAccessor.getSignedUrl) {
-                const expires = (0, util_1.expirationDetails)({ expiresAt, expiresIn });
+                const expiresIn = inputExpiresIn ?? util_1.MS_IN_MINUTE * 30;
+                const expires = (0, util_1.expirationDetails)({ defaultExpiresFromDateToNow: true, expiresAt, expiresIn });
                 let downloadUrlExpiresAt = expires.getExpirationDate();
                 // if they're not an admin, limit the expiration to a max of 30 days.
                 if (downloadUrlExpiresAt && !asAdmin) {
                     const maxExpirationDate = (0, date_fns_1.addDays)(new Date(), 30);
                     downloadUrlExpiresAt = (0, date_1.findMinDate)([downloadUrlExpiresAt, maxExpirationDate]);
                 }
-                const downloadUrl = await fileAccessor.getSignedUrl({
-                    action: 'read',
-                    expiresAt: downloadUrlExpiresAt ?? undefined,
-                    responseDisposition: responseDisposition ?? undefined, // can be set by anyone
-                    responseType: asAdmin ? (responseContentType ?? undefined) : undefined // can only be set by admins
-                });
+                const [downloadUrl, metadata] = await Promise.all([
+                    fileAccessor.getSignedUrl({
+                        action: 'read',
+                        expiresAt: downloadUrlExpiresAt ?? undefined,
+                        responseDisposition: responseDisposition ?? undefined, // can be set by anyone
+                        responseType: asAdmin ? (responseContentType ?? undefined) : undefined // can only be set by admins
+                    }),
+                    fileAccessor.getMetadata()
+                ]);
                 result = {
-                    url: downloadUrl
+                    url: downloadUrl,
+                    fileName: metadata.name ? (0, util_1.slashPathDetails)(metadata.name).end : undefined,
+                    mimeType: responseContentType ?? metadata.contentType,
+                    expiresAt: (0, util_1.unixDateTimeSecondsNumberFromDate)(downloadUrlExpiresAt)
                 };
             }
             else {
@@ -426,4 +488,261 @@ function downloadStorageFileFactory(context) {
         };
     });
 }
+function createStorageFileGroupInTransactionFactory(context) {
+    const { storageFileGroupCollection } = context;
+    return async (params, transaction) => {
+        const { now: inputNow, skipCreate, template } = params;
+        const now = inputNow ?? new Date();
+        const storageFileGroupDocument = (0, firebase_1.loadStorageFileGroupDocumentForReferencePair)(params, storageFileGroupCollection.documentAccessorForTransaction(transaction));
+        const storageFileGroupTemplate = {
+            o: (0, firebase_1.firestoreDummyKey)(), // set during initialization
+            cat: now,
+            s: true, // requires initialization
+            f: [],
+            ...template
+        };
+        if (!skipCreate) {
+            await storageFileGroupDocument.create(storageFileGroupTemplate);
+        }
+        return {
+            storageFileGroupTemplate,
+            storageFileGroupDocument
+        };
+    };
+}
+function createStorageFileGroupFactory(context) {
+    const { firestoreContext, firebaseServerActionTransformFunctionFactory } = context;
+    const createStorageFileGroupInTransaction = createStorageFileGroupInTransactionFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase_1.CreateStorageFileGroupParams, async (params) => {
+        const { model, storageFileId } = params;
+        const storageFileGroupRelatedModelKey = model ? model : storageFileId ? (0, firebase_1.inferKeyFromTwoWayFlatFirestoreModelKey)(storageFileId) : undefined;
+        if (!storageFileGroupRelatedModelKey) {
+            throw (0, storagefile_error_1.createStorageFileGroupInputError)();
+        }
+        return async () => {
+            const result = await firestoreContext.runTransaction(async (transaction) => {
+                const { storageFileGroupDocument } = await createStorageFileGroupInTransaction({ storageFileGroupRelatedModelKey }, transaction);
+                return storageFileGroupDocument;
+            });
+            return result;
+        };
+    });
+}
+function _syncStorageFileWithGroupsInTransactionFactory(context) {
+    const { storageFileCollection, storageFileGroupCollection } = context;
+    const createStorageFileGroupInTransaction = createStorageFileGroupInTransactionFactory(context);
+    return async (input, transaction) => {
+        const { storageFileDocument, storageFile: inputStorageFile, force, removeAllStorageFileGroups, skipStorageFileUpdate } = input;
+        const storageFileDocumentInTransaction = storageFileCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(storageFileDocument);
+        const storageFileGroupDocumentAccessor = storageFileGroupCollection.documentAccessorForTransaction(transaction);
+        const storageFile = inputStorageFile ?? (await (0, firebase_server_1.assertSnapshotData)(storageFileDocumentInTransaction));
+        if (!storageFile.gs && !force) {
+            throw (0, storagefile_error_1.storageFileNotFlaggedForGroupsSyncError)();
+        }
+        const g = storageFile.g ?? [];
+        const storageFileGroupDocuments = (0, firebase_1.loadDocumentsForIds)(storageFileGroupDocumentAccessor, g);
+        const storageFileGroupPairs = await (0, firebase_1.getDocumentSnapshotDataPairs)(storageFileGroupDocuments);
+        let storageFilesGroupsCreated = 0;
+        let storageFilesGroupsUpdated = 0;
+        await (0, util_1.performAsyncTasks)(storageFileGroupPairs, async (storageFileGroupPair) => {
+            const { data: storageFileGroup, document: storageFileGroupDocument } = storageFileGroupPair;
+            const existsInStorageFileGroup = storageFileGroup?.f.some((x) => x.s === storageFileDocument.id);
+            const change = removeAllStorageFileGroups ? (existsInStorageFileGroup ? 'remove' : undefined) : !existsInStorageFileGroup ? 'add' : undefined;
+            switch (change) {
+                case 'add':
+                    // add it if it doesn't exist
+                    const createTemplate = (0, firebase_1.calculateStorageFileGroupEmbeddedFileUpdate)({
+                        storageFileGroup: storageFileGroup ?? { f: [] },
+                        insert: [
+                            {
+                                s: storageFileDocument.id
+                            }
+                        ],
+                        allowRecalculateRegenerateFlag: false
+                    });
+                    if (!storageFileGroup) {
+                        // if the group does not exist, then create it
+                        await createStorageFileGroupInTransaction({ storageFileGroupDocument, template: createTemplate }, transaction);
+                        storageFilesGroupsCreated += 1;
+                    }
+                    else {
+                        // if the group exists, then update it
+                        await storageFileGroupDocument.update(createTemplate);
+                        storageFilesGroupsUpdated += 1;
+                    }
+                    break;
+                case 'remove':
+                    // remove it
+                    const removeTemplate = (0, firebase_1.calculateStorageFileGroupEmbeddedFileUpdate)({
+                        storageFileGroup: storageFileGroup ?? { f: [] },
+                        remove: [storageFileDocument.id]
+                    });
+                    await storageFileGroupDocument.update(removeTemplate);
+                    storageFilesGroupsUpdated += 1;
+                    break;
+            }
+        });
+        const result = {
+            storageFilesGroupsCreated,
+            storageFilesGroupsUpdated
+        };
+        // update the storage file to no longer be flagged for sync
+        if (!skipStorageFileUpdate) {
+            await storageFileDocumentInTransaction.update({
+                gs: false
+            });
+        }
+        return result;
+    };
+}
+function syncStorageFileWithGroupsFactory(context) {
+    const { firestoreContext, storageFileCollection, storageFileGroupCollection, firebaseServerActionTransformFunctionFactory } = context;
+    const syncStorageFileWithGroupsInTransaction = _syncStorageFileWithGroupsInTransactionFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase_1.SyncStorageFileWithGroupsParams, async (params) => {
+        const { force } = params;
+        return async (storageFileDocument) => {
+            return firestoreContext.runTransaction(async (transaction) => syncStorageFileWithGroupsInTransaction({ storageFileDocument, force }, transaction));
+        };
+    });
+}
+function syncAllFlaggedStorageFilesWithGroupsFactory(context) {
+    const { firebaseServerActionTransformFunctionFactory, storageFileCollection } = context;
+    const syncStorageFileWithGroups = syncStorageFileWithGroupsFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase_1.SyncAllFlaggedStorageFilesWithGroupsParams, async (params) => {
+        return async () => {
+            const syncStorageFileWithGroupsInstance = await syncStorageFileWithGroups({
+                key: (0, firebase_1.firestoreDummyKey)(),
+                force: true // force anyways; they should all be flagged for sync when the query hits
+            });
+            let storageFilesSynced = 0;
+            let storageFilesGroupsCreated = 0;
+            let storageFilesGroupsUpdated = 0;
+            await (0, firebase_1.iterateFirestoreDocumentSnapshotPairBatches)({
+                documentAccessor: storageFileCollection.documentAccessor(),
+                iterateSnapshotPairsBatch: async (snapshotPairBatch) => {
+                    // only sync StorageFiles that are flagged for sync
+                    await (0, util_1.runAsyncTasksForValues)(snapshotPairBatch.filter((x) => x.data.gs), async (snapshotPair) => {
+                        const { document: storageFileDocument } = snapshotPair;
+                        const result = await syncStorageFileWithGroupsInstance(storageFileDocument);
+                        storageFilesSynced += 1;
+                        storageFilesGroupsCreated += result.storageFilesGroupsCreated;
+                        storageFilesGroupsUpdated += result.storageFilesGroupsUpdated;
+                    }, {
+                        maxParallelTasks: 10, // can update 10 storageFiles/Groups at the same time
+                        nonConcurrentTaskKeyFactory: (x) => x.data.g // do not update the same group at the same time
+                    });
+                },
+                queryFactory: storageFileCollection,
+                constraintsFactory: () => (0, firebase_1.storageFileFlaggedForSyncWithGroupsQuery)(),
+                performTasksConfig: {
+                    sequential: true // run batches sequentially to avoid contention in updating a StorageFileGroup
+                },
+                totalSnapshotsLimit: 1000,
+                limitPerCheckpoint: 100
+            });
+            const result = {
+                storageFilesSynced,
+                storageFilesGroupsCreated,
+                storageFilesGroupsUpdated
+            };
+            return result;
+        };
+    });
+}
+function regenerateStorageFileGroupContentFactory(context) {
+    const { firestoreContext, storageService, storageFileCollection, storageFileGroupCollection, firebaseServerActionTransformFunctionFactory } = context;
+    const processStorageFileInTransaction = _processStorageFileInTransactionFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase_1.RegenerateStorageFileGroupContentParams, async (params) => {
+        const { force } = params;
+        const createStorageFileDocumentPair = (0, firebase_1.createStorageFileDocumentPairFactory)({
+            defaultCreationType: firebase_1.StorageFileCreationType.FOR_STORAGE_FILE_GROUP
+        });
+        return async (storageFileGroupDocument) => {
+            return firestoreContext.runTransaction(async (transaction) => {
+                const storageFileGroupDocumentInTransaction = storageFileGroupCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(storageFileGroupDocument);
+                const storageFileGroup = await (0, firebase_server_1.assertSnapshotData)(storageFileGroupDocumentInTransaction);
+                const storageFileDocumentAccessor = storageFileCollection.documentAccessorForTransaction(transaction);
+                const { o, zsf, s } = storageFileGroup;
+                // must not be queued for initialization
+                if (s) {
+                    throw (0, storagefile_error_1.storageFileGroupQueuedForInitializationError)();
+                }
+                const existingZipStorageFileDocument = zsf ? storageFileDocumentAccessor.loadDocumentForId(zsf) : undefined;
+                const [existingZipStorageFilePair] = await Promise.all([existingZipStorageFileDocument ? (0, firebase_1.getDocumentSnapshotDataPair)(existingZipStorageFileDocument) : undefined]);
+                let contentStorageFilesFlaggedForProcessing = 0;
+                const updateTemplate = {
+                    re: false // clear the regeneration flag
+                };
+                // For each content type, create/update/flag the StorageFile for processing that type
+                const { regenerateZip } = (0, firebase_1.calculateStorageFileGroupRegeneration)({ storageFileGroup, force });
+                if (regenerateZip) {
+                    // check that the storageFile exists, and if it doesn't, create a new one
+                    if (!existingZipStorageFilePair?.data) {
+                        const zipStorageFile = storageService.file((0, firebase_1.storageFileGroupZipFileStoragePath)(storageFileGroupDocument.id));
+                        // create a new StorageFile
+                        const { storageFileDocument } = await createStorageFileDocumentPair({
+                            storagePathRef: zipStorageFile,
+                            accessor: storageFileDocumentAccessor,
+                            parentStorageFileGroup: storageFileGroupDocument,
+                            purpose: firebase_1.STORAGE_FILE_GROUP_ZIP_STORAGE_FILE_PURPOSE,
+                            shouldBeProcessed: true,
+                            ownershipKey: o,
+                            metadata: {
+                                sfg: storageFileGroupDocument.id
+                            }
+                        });
+                        updateTemplate.zsf = storageFileDocument.id;
+                    }
+                    else {
+                        // flag it for processing again
+                        await processStorageFileInTransaction({ params: { processAgainIfSuccessful: true }, storageFileDocument: existingZipStorageFilePair.document, storageFile: existingZipStorageFilePair.data }, transaction);
+                    }
+                    contentStorageFilesFlaggedForProcessing += 1;
+                }
+                // update the StorageFileGroup
+                await storageFileGroupDocumentInTransaction.update(updateTemplate);
+                const result = {
+                    contentStorageFilesFlaggedForProcessing
+                };
+                return result;
+            });
+        };
+    });
+}
+function regenerateAllFlaggedStorageFileGroupsContentFactory(context) {
+    const { firebaseServerActionTransformFunctionFactory, storageFileGroupCollection } = context;
+    const regenerateStorageFileGroupContent = regenerateStorageFileGroupContentFactory(context);
+    return firebaseServerActionTransformFunctionFactory(firebase_1.RegenerateAllFlaggedStorageFileGroupsContentParams, async (params) => {
+        return async () => {
+            const regenerateStorageFileGroupContentInstance = await regenerateStorageFileGroupContent({
+                key: (0, firebase_1.firestoreDummyKey)()
+            });
+            let storageFileGroupsUpdated = 0;
+            let contentStorageFilesFlaggedForProcessing = 0;
+            await (0, firebase_1.iterateFirestoreDocumentSnapshotPairs)({
+                documentAccessor: storageFileGroupCollection.documentAccessor(),
+                iterateSnapshotPair: async (snapshotPair) => {
+                    const { data: storageFileGroup } = snapshotPair;
+                    if (!storageFileGroup.s) {
+                        const result = await regenerateStorageFileGroupContentInstance(snapshotPair.document);
+                        storageFileGroupsUpdated += 1;
+                        contentStorageFilesFlaggedForProcessing += result.contentStorageFilesFlaggedForProcessing;
+                    }
+                },
+                queryFactory: storageFileGroupCollection,
+                constraintsFactory: () => (0, firebase_1.storageFileGroupsFlaggedForContentRegenerationQuery)(),
+                performTasksConfig: {
+                    maxParallelTasks: 10
+                },
+                totalSnapshotsLimit: 1000,
+                limitPerCheckpoint: 100
+            });
+            const result = {
+                storageFileGroupsUpdated,
+                contentStorageFilesFlaggedForProcessing
+            };
+            return result;
+        };
+    });
+}
 //# sourceMappingURL=storagefile.action.server.js.map