@dereekb/firebase-server 12.6.21 → 13.0.0

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

@@ -1,797 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StorageFileServerActions = exports.STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN = exports.BASE_STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN = void 0;
-exports.storageFileServerActions = storageFileServerActions;
-exports.createStorageFileFactory = createStorageFileFactory;
-exports.initializeAllStorageFilesFromUploadsFactory = initializeAllStorageFilesFromUploadsFactory;
-exports._initializeStorageFileFromUploadFileFactory = _initializeStorageFileFromUploadFileFactory;
-exports.initializeStorageFileFromUploadFactory = initializeStorageFileFromUploadFactory;
-exports.updateStorageFileFactory = updateStorageFileFactory;
-exports.updateStorageFileGroupFactory = updateStorageFileGroupFactory;
-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");
-const util_1 = require("@dereekb/util");
-const date_1 = require("@dereekb/date");
-const date_fns_1 = require("date-fns");
-/**
- * Injection token for the BaseStorageFileServerActionsContext
- */
-exports.BASE_STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN = 'BASE_STORAGE_FILE_SERVER_ACTION_CONTEXT';
-/**
- * Injection token for the StorageFileServerActionsContext
- */
-exports.STORAGE_FILE_SERVER_ACTION_CONTEXT_TOKEN = 'STORAGE_FILE_SERVER_ACTION_CONTEXT';
-class StorageFileServerActions {
-}
-exports.StorageFileServerActions = StorageFileServerActions;
-function storageFileServerActions(context) {
-    return {
-        createStorageFile: createStorageFileFactory(context),
-        initializeAllStorageFilesFromUploads: initializeAllStorageFilesFromUploadsFactory(context),
-        initializeStorageFileFromUpload: initializeStorageFileFromUploadFactory(context),
-        updateStorageFile: updateStorageFileFactory(context),
-        processAllQueuedStorageFiles: processAllQueuedStorageFilesFactory(context),
-        processStorageFile: processStorageFileFactory(context),
-        deleteAllQueuedStorageFiles: deleteAllQueuedStorageFilesFactory(context),
-        deleteStorageFile: deleteStorageFileFactory(context),
-        downloadStorageFile: downloadStorageFileFactory(context),
-        createStorageFileGroup: createStorageFileGroupFactory(context),
-        updateStorageFileGroup: updateStorageFileGroupFactory(context),
-        syncStorageFileWithGroups: syncStorageFileWithGroupsFactory(context),
-        syncAllFlaggedStorageFilesWithGroups: syncAllFlaggedStorageFilesWithGroupsFactory(context),
-        regenerateStorageFileGroupContent: regenerateStorageFileGroupContentFactory(context),
-        regenerateAllFlaggedStorageFileGroupsContent: regenerateAllFlaggedStorageFileGroupsContentFactory(context)
-    };
-}
-// MARK: Actions
-function createStorageFileFactory(context) {
-    const { storageFileCollection, firestoreContext, firebaseServerActionTransformFunctionFactory } = context;
-    return firebaseServerActionTransformFunctionFactory(firebase_1.CreateStorageFileParams, async (params) => {
-        const {} = params;
-        return async () => {
-            const storageFileDocument = null;
-            // TODO: check the file exists, and pull the metadata, and create the document
-            return storageFileDocument;
-        };
-    });
-}
-function initializeAllStorageFilesFromUploadsFactory(context) {
-    const { storageService, firebaseServerActionTransformFunctionFactory } = context;
-    const _initializeStorageFileFromUploadFile = _initializeStorageFileFromUploadFileFactory(context);
-    return firebaseServerActionTransformFunctionFactory(firebase_1.InitializeAllStorageFilesFromUploadsParams, async (params) => {
-        const { folderPath, maxFilesToInitialize, overrideUploadsFolderPath } = params;
-        const fullPath = (0, util_1.mergeSlashPaths)([overrideUploadsFolderPath ?? firebase_1.UPLOADS_FOLDER_PATH, folderPath]); // only targets the uploads folder
-        return async () => {
-            const folder = storageService.folder(fullPath);
-            const modelKeys = [];
-            let filesVisited = 0;
-            let initializationsSuccessCount = 0;
-            let initializationsFailureCount = 0;
-            await (0, firebase_1.iterateStorageListFilesByEachFile)({
-                folder,
-                includeNestedResults: true,
-                readItemsFromPageResult: (results) => results.result.files(),
-                iterateEachPageItem: async (file) => {
-                    const fileInstance = file.file();
-                    const initializeResult = await _initializeStorageFileFromUploadFile({ file: fileInstance }).catch(() => null);
-                    filesVisited++;
-                    if (initializeResult) {
-                        initializationsSuccessCount++;
-                        modelKeys.push(initializeResult.key);
-                    }
-                    else {
-                        initializationsFailureCount++;
-                    }
-                },
-                /**
-                 * The maximum number of files to initialize at once.
-                 */
-                iterateItemsLimit: maxFilesToInitialize ?? 1000,
-                /**
-                 * Iterate four separate pages at a time
-                 */
-                maxParallelPages: 4
-            });
-            const result = {
-                modelKeys,
-                filesVisited,
-                initializationsSuccessCount,
-                initializationsFailureCount
-            };
-            return result;
-        };
-    });
-}
-function _initializeStorageFileFromUploadFileFactory(context) {
-    const { firestoreContext, storageFileInitializeFromUploadService, notificationExpediteService } = context;
-    const processStorageFileInTransaction = _processStorageFileInTransactionFactory(context);
-    return async (input) => {
-        const { file, expediteProcessing } = input;
-        const { bucketId, pathString } = file.storagePath;
-        // file must exist
-        const exists = await file.exists();
-        if (!exists) {
-            throw (0, storagefile_error_1.uploadedFileDoesNotExistError)();
-        }
-        // file must be allowed to be initialized
-        const isAllowedToBeInitialized = await storageFileInitializeFromUploadService.checkFileIsAllowedToBeInitialized(file);
-        if (!isAllowedToBeInitialized) {
-            throw (0, storagefile_error_1.uploadedFileIsNotAllowedToBeInitializedError)();
-        }
-        let storageFileDocument;
-        let initializationResult;
-        let httpsError;
-        try {
-            initializationResult = await storageFileInitializeFromUploadService.initializeFromUpload({
-                file
-            });
-            async function deleteFile() {
-                try {
-                    // can now delete the uploaded file
-                    await file.delete();
-                }
-                catch (e) {
-                    // log errors here, but do nothing.
-                    console.error(`initializeStorageFileFromUpload(): Error deleting uploaded file (${bucketId}/${pathString})`, e);
-                }
-            }
-            switch (initializationResult.resultType) {
-                case 'success':
-                    await deleteFile();
-                    if (initializationResult.storageFileDocument) {
-                        storageFileDocument = initializationResult.storageFileDocument;
-                        // expedite processing if requested
-                        if (storageFileDocument != null && expediteProcessing) {
-                            const storageFile = await (0, firebase_server_1.assertSnapshotData)(storageFileDocument);
-                            if (storageFile.ps === firebase_1.StorageFileProcessingState.QUEUED_FOR_PROCESSING) {
-                                const expediteInstance = notificationExpediteService.expediteInstance();
-                                await firestoreContext.runTransaction(async (transaction) => {
-                                    expediteInstance.initialize();
-                                    await processStorageFileInTransaction({
-                                        storageFileDocument: storageFileDocument,
-                                        expediteInstance
-                                    }, transaction);
-                                });
-                                await expediteInstance.send().catch(() => null);
-                            }
-                        }
-                    }
-                    else {
-                        httpsError = (0, storagefile_error_1.uploadedFileInitializationDiscardedError)();
-                    }
-                    break;
-                case 'initializer_error':
-                    if (initializationResult.initializationError) {
-                        throw initializationResult.initializationError; // re-throw the encountered error
-                    }
-                    break;
-                case 'permanent_initializer_failure':
-                    // log the error
-                    if (initializationResult.initializationError) {
-                        console.warn(`initializeStorageFileFromUpload(): Permanent initializer failure for file (${bucketId}/${pathString})`, initializationResult.initializationError);
-                    }
-                    // delete the file
-                    await deleteFile();
-                    // return the error
-                    httpsError = (0, storagefile_error_1.uploadedFileInitializationFailedError)({
-                        resultType: initializationResult.resultType,
-                        fileDeleted: true
-                    });
-                    break;
-                case 'no_determiner_match':
-                case 'no_initializer_configured':
-                default:
-                    httpsError = (0, storagefile_error_1.uploadedFileInitializationFailedError)({
-                        resultType: initializationResult.resultType
-                    });
-                    console.error(`initializeStorageFileFromUpload(): Unknown file type (${initializationResult.resultType}) encountered for storage file "${bucketId}/${pathString}".`);
-                    break;
-            }
-        }
-        catch (e) {
-            console.error(`initializeStorageFileFromUpload(): Error while initializing storage file (${bucketId}/${pathString}) from upload`, e);
-            httpsError = (0, storagefile_error_1.uploadedFileInitializationFailedError)({ resultType: 'initializer_error' });
-        }
-        if (httpsError) {
-            throw httpsError;
-        }
-        else if (!storageFileDocument) {
-            throw (0, storagefile_error_1.uploadedFileInitializationDiscardedError)(); // throw again for redundancy
-        }
-        return storageFileDocument;
-    };
-}
-function initializeStorageFileFromUploadFactory(context) {
-    const { storageService, firebaseServerActionTransformFunctionFactory } = context;
-    const _initializeStorageFileFromUploadFile = _initializeStorageFileFromUploadFileFactory(context);
-    return firebaseServerActionTransformFunctionFactory(firebase_1.InitializeStorageFileFromUploadParams, async (params) => {
-        const { bucketId, pathString, expediteProcessing } = params;
-        return async () => {
-            const file = storageService.file(bucketId == null ? pathString : { bucketId, pathString });
-            return _initializeStorageFileFromUploadFile({ file, expediteProcessing });
-        };
-    });
-}
-function updateStorageFileFactory(context) {
-    const { storageFileCollection, firestoreContext, firebaseServerActionTransformFunctionFactory } = context;
-    return firebaseServerActionTransformFunctionFactory(firebase_1.UpdateStorageFileParams, async (params) => {
-        const { sdat } = params;
-        return async (storageFileDocument) => {
-            const updateTemplate = {
-                sdat
-            };
-            await storageFileDocument.update(updateTemplate);
-            return storageFileDocument;
-        };
-    });
-}
-function updateStorageFileGroupFactory(context) {
-    const { firestoreContext, storageFileGroupCollection, firebaseServerActionTransformFunctionFactory } = context;
-    return firebaseServerActionTransformFunctionFactory(firebase_1.UpdateStorageFileGroupParams, async (params) => {
-        const { entries } = params;
-        return async (storageFileGroupDocument) => {
-            await firestoreContext.runTransaction(async (transaction) => {
-                const storageFileGroupDocumentInTransaction = storageFileGroupCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(storageFileGroupDocument);
-                const storageFileGroup = await (0, firebase_server_1.assertSnapshotData)(storageFileGroupDocumentInTransaction);
-                let f = undefined;
-                // update entries
-                if (entries?.length) {
-                    f = util_1.ModelRelationUtility.updateCollection(storageFileGroup.f, entries, {
-                        readKey: (x) => x.s,
-                        merge: (existing, update) => {
-                            const n = update.n === undefined ? existing.n : update.n;
-                            return {
-                                ...existing,
-                                n
-                            };
-                        }
-                    });
-                }
-                const updateTemplate = {
-                    f
-                };
-                await storageFileGroupDocumentInTransaction.update(updateTemplate);
-            });
-            return storageFileGroupDocument;
-        };
-    });
-}
-function processAllQueuedStorageFilesFactory(context) {
-    const { storageFileCollection, firebaseServerActionTransformFunctionFactory } = context;
-    const processStorageFile = processStorageFileFactory(context);
-    return firebaseServerActionTransformFunctionFactory(firebase_1.ProcessAllQueuedStorageFilesParams, async (params) => {
-        return async () => {
-            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 processStorageFileInstance(snapshotPair.document).catch(() => null);
-                    if (processStorageFileResult) {
-                        storageFilesProcessStarted++;
-                    }
-                    else {
-                        storageFilesFailedStarting++;
-                    }
-                },
-                constraintsFactory: () => (0, firebase_1.storageFilesQueuedForProcessingQuery)(),
-                queryFactory: storageFileCollection,
-                batchSize: undefined,
-                performTasksConfig: {
-                    maxParallelTasks: 10
-                }
-            });
-            const result = {
-                storageFilesVisited,
-                storageFilesProcessStarted,
-                storageFilesFailedStarting
-            };
-            return result;
-        };
-    });
-}
-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 { firestoreContext, notificationExpediteService, firebaseServerActionTransformFunctionFactory } = context;
-    const processStorageFileInTransaction = _processStorageFileInTransactionFactory(context);
-    return firebaseServerActionTransformFunctionFactory(firebase_1.ProcessStorageFileParams, async (params) => {
-        const { runImmediately } = params;
-        return async (storageFileDocument) => {
-            const expediteInstance = notificationExpediteService.expediteInstance();
-            await firestoreContext.runTransaction(async (transaction) => {
-                expediteInstance.initialize();
-                await processStorageFileInTransaction({
-                    storageFileDocument,
-                    params,
-                    expediteInstance
-                }, transaction);
-            });
-            let expediteResult = null;
-            // expedite the task if requested
-            if (runImmediately) {
-                expediteResult = await expediteInstance.send().then((x) => x[0]);
-            }
-            const result = {
-                runImmediately: runImmediately ?? false,
-                expediteResult
-            };
-            return result;
-        };
-    });
-}
-function deleteAllQueuedStorageFilesFactory(context) {
-    const { storageFileCollection, firebaseServerActionTransformFunctionFactory } = context;
-    const deleteStorageFile = deleteStorageFileFactory(context);
-    return firebaseServerActionTransformFunctionFactory(firebase_1.DeleteAllQueuedStorageFilesParams, async (params) => {
-        return async () => {
-            let storageFilesVisited = 0;
-            let storageFilesDeleted = 0;
-            let storageFilesFailedDeleting = 0;
-            const deleteStorageFileInstance = await deleteStorageFile({
-                key: (0, firebase_1.firestoreDummyKey)()
-            });
-            await (0, firebase_1.iterateFirestoreDocumentSnapshotPairs)({
-                documentAccessor: storageFileCollection.documentAccessor(),
-                iterateSnapshotPair: async (snapshotPair) => {
-                    const { document: storageFileDocument } = snapshotPair;
-                    storageFilesVisited++;
-                    const deleteStorageFileResult = await deleteStorageFileInstance(storageFileDocument)
-                        .then(() => true)
-                        .catch(() => false);
-                    if (deleteStorageFileResult) {
-                        storageFilesDeleted++;
-                    }
-                    else {
-                        storageFilesFailedDeleting++;
-                    }
-                },
-                constraintsFactory: () => (0, firebase_1.storageFilesQueuedForDeleteQuery)(),
-                queryFactory: storageFileCollection,
-                batchSize: undefined,
-                performTasksConfig: {
-                    maxParallelTasks: 10
-                }
-            });
-            const result = {
-                storageFilesDeleted,
-                storageFilesFailedDeleting,
-                storageFilesVisited
-            };
-            return result;
-        };
-    });
-}
-function deleteStorageFileFactory(context) {
-    const { firestoreContext, storageService, storageFileCollection, firebaseServerActionTransformFunctionFactory } = context;
-    const syncStorageFileWithGroupsInTransaction = _syncStorageFileWithGroupsInTransactionFactory(context);
-    return firebaseServerActionTransformFunctionFactory(firebase_1.DeleteStorageFileParams, async (params) => {
-        const { force } = params;
-        return async (inputStorageFileDocument) => {
-            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)();
-                    }
-                }
-                // 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, storageFileCollection } = context;
-    return firebaseServerActionTransformFunctionFactory(firebase_1.DownloadStorageFileParams, async (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 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, 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,
-                    fileName: metadata.name ? (0, util_1.slashPathDetails)(metadata.name).end : undefined,
-                    mimeType: responseContentType ?? metadata.contentType,
-                    expiresAt: (0, util_1.unixDateTimeSecondsNumberFromDate)(downloadUrlExpiresAt)
-                };
-            }
-            else {
-                throw (0, firebase_server_1.internalServerError)('Signed url function appears to not be avalable.');
-            }
-            return result;
-        };
-    });
-}
-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