@dereekb/firebase 13.0.6 → 13.1.0

package/src/lib/model/storagefile/storagefile.api.d.ts

@@ -1,6 +1,7 @@
-import { TargetModelParams, OnCallCreateModelResult, FirestoreModelKey } from '../../common';
-import { type ModelFirebaseCrudFunction, type FirebaseFunctionTypeConfigMap, type ModelFirebaseCrudFunctionConfigMap, type ModelFirebaseFunctionMap, ModelFirebaseCreateFunction } from '../../client';
-import { StorageFileSignedDownloadUrl, StorageFileTypes } from './storagefile';
+import { type Type } from 'arktype';
+import { type TargetModelParams, type OnCallCreateModelResult, type FirestoreModelKey } from '../../common';
+import { type ModelFirebaseCrudFunction, type FirebaseFunctionTypeConfigMap, type ModelFirebaseCrudFunctionConfigMap, type ModelFirebaseFunctionMap, type ModelFirebaseCreateFunction } from '../../client';
+import { type StorageFileSignedDownloadUrl, type StorageFileTypes } from './storagefile';
 import { type StorageBucketId, type StoragePath, type StorageSlashPath } from '../../common/storage';
 import { type ContentDispositionString, type ContentTypeMimeType, type Maybe, type Milliseconds, type UnixDateTimeSecondsNumber } from '@dereekb/util';
 import { type StorageFileId } from './storagefile.id';
@@ -8,25 +9,18 @@ import { type SendNotificationResult } from '../notification/notification.api';
 /**
  * Used for directly create a new StorageFile.
  */
-export declare class CreateStorageFileParams {
+export interface CreateStorageFileParams {
 }
+export declare const createStorageFileParamsType: Type<CreateStorageFileParams>;
 /**
  * Initializes all StorageFiles in the uploads folder.
  */
-export declare class InitializeAllStorageFilesFromUploadsParams {
-    /**
-     * The maximum number of files to initialize at once.
-     */
-    maxFilesToInitialize?: Maybe<number>;
-    /**
-     * The specific folder under the uploads folder to search for files and initialize
-     */
-    folderPath?: Maybe<StorageSlashPath>;
-    /**
-     * Overrides the default uploads folder path.
-     */
-    overrideUploadsFolderPath?: Maybe<StorageSlashPath>;
+export interface InitializeAllStorageFilesFromUploadsParams {
+    readonly maxFilesToInitialize?: Maybe<number>;
+    readonly folderPath?: Maybe<StorageSlashPath>;
+    readonly overrideUploadsFolderPath?: Maybe<StorageSlashPath>;
 }
+export declare const initializeAllStorageFilesFromUploadsParamsType: Type<InitializeAllStorageFilesFromUploadsParams>;
 export interface InitializeAllStorageFilesFromUploadsResult extends OnCallCreateModelResult {
     readonly filesVisited: number;
     readonly initializationsSuccessCount: number;
@@ -35,146 +29,68 @@ export interface InitializeAllStorageFilesFromUploadsResult extends OnCallCreate
 /**
  * Initializes a StorageFile from the document at the given path.
  */
-export declare class InitializeStorageFileFromUploadParams implements Pick<StoragePath, 'pathString'> {
-    /**
-     * Specific bucketId to use.
-     *
-     * If not defined, the default bucket will be used.
-     */
-    bucketId?: Maybe<StorageBucketId>;
-    pathString: StorageSlashPath;
-    /**
-     * Whether or not to attempt to expedite the processing of the created StorageFile, if it is queued for processing.
-     *
-     * If it cannot be processed, this argument will have no effect.
-     */
-    expediteProcessing?: boolean;
-}
-export declare class ProcessStorageFileParams extends TargetModelParams {
-    /**
-     * If set, will start/run the processing immediately instead of waiting for the next scheduled run.
-     */
-    runImmediately?: Maybe<boolean>;
-    /**
-     * If set, will check and retry processing if the StorageFile is in a failed processing state.
-     */
-    checkRetryProcessing?: Maybe<boolean>;
-    /**
-     * Used with checkRetryProcessing.
-     *
-     * If set, will forcibly create a new processing task even if the existing processing task appears to be ok, or if processing was already marked complete.
-     */
-    forceRestartProcessing?: Maybe<boolean>;
-    /**
-     * If set, will start the processing again if the StorageFile is in a successful processing state.
-     */
-    processAgainIfSuccessful?: Maybe<boolean>;
-}
+export interface InitializeStorageFileFromUploadParams extends Pick<StoragePath, 'pathString'> {
+    readonly bucketId?: Maybe<StorageBucketId>;
+    readonly pathString: StorageSlashPath;
+    readonly expediteProcessing?: boolean;
+}
+export declare const initializeStorageFileFromUploadParamsType: Type<InitializeStorageFileFromUploadParams>;
+export interface ProcessStorageFileParams extends TargetModelParams {
+    readonly runImmediately?: Maybe<boolean>;
+    readonly checkRetryProcessing?: Maybe<boolean>;
+    readonly forceRestartProcessing?: Maybe<boolean>;
+    readonly processAgainIfSuccessful?: Maybe<boolean>;
+}
+export declare const processStorageFileParamsType: Type<ProcessStorageFileParams>;
 export interface ProcessStorageFileResult {
-    /**
-     * Whether or not the StorageFile was run immediately.
-     */
     readonly runImmediately: boolean;
-    /**
-     * The expedite result, if runImmediately returned true.
-     */
     readonly expediteResult: Maybe<SendNotificationResult>;
 }
 /**
  * Processes all StorageFiles that are queued for processing.
  */
-export declare class ProcessAllQueuedStorageFilesParams {
+export interface ProcessAllQueuedStorageFilesParams {
 }
+export declare const processAllQueuedStorageFilesParamsType: Type<ProcessAllQueuedStorageFilesParams>;
 export interface ProcessAllQueuedStorageFilesResult {
-    /**
-     * The total number of StorageFiles visited.
-     */
     readonly storageFilesVisited: number;
-    /**
-     * The total number of StorageFiles that started processing.
-     */
     readonly storageFilesProcessStarted: number;
-    /**
-     * The total number of StorageFiles that failed to start processing.
-     */
     readonly storageFilesFailedStarting: number;
 }
-export declare class UpdateStorageFileParams extends TargetModelParams {
-    /**
-     * Sets the delete at time for the given StorageFileDocument, and queues the file for deletion.
-     */
-    sdat?: Maybe<Date>;
+export interface UpdateStorageFileParams extends TargetModelParams {
+    readonly sdat?: Maybe<Date>;
 }
-export declare class DeleteStorageFileParams extends TargetModelParams {
-    /**
-     * If true, will force the deletion of the StorageFile even if it is not queued for deletion.
-     */
-    force?: Maybe<boolean>;
+export declare const updateStorageFileParamsType: Type<UpdateStorageFileParams>;
+export interface DeleteStorageFileParams extends TargetModelParams {
+    readonly force?: Maybe<boolean>;
 }
+export declare const deleteStorageFileParamsType: Type<DeleteStorageFileParams>;
 /**
  * Processes all StorageFiles that are queued for processing.
  */
-export declare class DeleteAllQueuedStorageFilesParams {
+export interface DeleteAllQueuedStorageFilesParams {
 }
+export declare const deleteAllQueuedStorageFilesParamsType: Type<DeleteAllQueuedStorageFilesParams>;
 export interface DeleteAllQueuedStorageFilesResult {
-    /**
-     * The total number of StorageFiles visited.
-     */
     readonly storageFilesVisited: number;
-    /**
-     * The total number of StorageFiles that were deleted.
-     */
     readonly storageFilesDeleted: number;
-    /**
-     * The total number of StorageFiles that failed to delete.
-     */
     readonly storageFilesFailedDeleting: number;
 }
-export declare class DownloadStorageFileParams extends TargetModelParams {
-    /**
-     * Date to expire the download URL.
-     */
-    expiresAt?: Maybe<Date>;
-    /**
-     * Duration in milliseconds to expire the download URL from now.
-     */
-    expiresIn?: Maybe<Milliseconds>;
-    /**
-     * The content disposition for the response to use.
-     */
-    responseDisposition?: Maybe<ContentDispositionString>;
-    /**
-     * The content type for the response to use.
-     *
-     * Only available to admins.
-     */
-    responseContentType?: Maybe<ContentTypeMimeType>;
-    /**
-     * Whether or not an admin is creating the link.
-     *
-     * Allows a longer expiration.
-     */
-    asAdmin?: Maybe<boolean>;
+export interface DownloadStorageFileParams extends TargetModelParams {
+    readonly expiresAt?: Maybe<Date>;
+    readonly expiresIn?: Maybe<Milliseconds>;
+    readonly responseDisposition?: Maybe<ContentDispositionString>;
+    readonly responseContentType?: Maybe<ContentTypeMimeType>;
+    readonly asAdmin?: Maybe<boolean>;
 }
+export declare const downloadStorageFileParamsType: Type<DownloadStorageFileParams>;
 /**
  * Result of downloading a StorageFile.
  */
 export interface DownloadStorageFileResult {
-    /**
-     * The download URL.
-     */
     readonly url: StorageFileSignedDownloadUrl;
-    /**
-     * The name of the StorageFile, if available.
-     */
     readonly fileName?: Maybe<string>;
-    /**
-     * The mime type of the StorageFile, if available.
-     */
     readonly mimeType?: Maybe<ContentTypeMimeType>;
-    /**
-     * Expiration time as a UnixDateTimeSecondsNumber value.
-     */
     readonly expiresAt?: Maybe<UnixDateTimeSecondsNumber>;
 }
 /**
@@ -184,93 +100,60 @@ export interface DownloadStorageFileResult {
  *
  * The preferred way is to create a StorageFileGroup through a StorageFile.
  */
-export declare class CreateStorageFileGroupParams {
-    /**
-     * ModelKey to use for creating the StorageFileGroup.
-     */
-    model?: Maybe<FirestoreModelKey>;
-    /**
-     * StorageFileId to use for creating the StorageFileGroup.
-     */
-    storageFileId?: Maybe<StorageFileId>;
+export interface CreateStorageFileGroupParams {
+    readonly model?: Maybe<FirestoreModelKey>;
+    readonly storageFileId?: Maybe<StorageFileId>;
 }
-export declare class SyncStorageFileWithGroupsParams extends TargetModelParams {
-    /**
-     * If true, will force syncing even if the StorageFile is not flagged for a resync.
-     */
-    force?: boolean;
+export declare const createStorageFileGroupParamsType: Type<CreateStorageFileGroupParams>;
+export interface SyncStorageFileWithGroupsParams extends TargetModelParams {
+    readonly force?: boolean;
 }
+export declare const syncStorageFileWithGroupsParamsType: Type<SyncStorageFileWithGroupsParams>;
 export interface SyncStorageFileWithGroupsResult {
-    /**
-     * The number of StorageFileGroups that were created.
-     */
     readonly storageFilesGroupsCreated: number;
-    /**
-     * The number of StorageFileGroups that were updated.
-     */
     readonly storageFilesGroupsUpdated: number;
 }
-export declare class SyncAllFlaggedStorageFilesWithGroupsParams {
+export interface SyncAllFlaggedStorageFilesWithGroupsParams {
 }
+export declare const syncAllFlaggedStorageFilesWithGroupsParamsType: Type<SyncAllFlaggedStorageFilesWithGroupsParams>;
 export interface SyncAllFlaggedStorageFilesWithGroupsResult {
-    /**
-     * The total number of StorageFiles that were synced.
-     */
     readonly storageFilesSynced: number;
-    /**
-     * The total number of StorageFileGroups that were created.
-     */
     readonly storageFilesGroupsCreated: number;
-    /**
-     * The total number of StorageFileGroups that were updated.
-     */
     readonly storageFilesGroupsUpdated: number;
 }
-export declare class UpdateStorageFileGroupParams extends TargetModelParams {
-    /**
-     * Entries to update, if selected.
-     */
-    entries?: Maybe<UpdateStorageFileGroupEntryParams[]>;
+export interface UpdateStorageFileGroupEntryParams {
+    readonly s: StorageFileId;
+    readonly n?: Maybe<string>;
 }
-export declare class UpdateStorageFileGroupEntryParams {
-    s: StorageFileId;
-    n?: Maybe<string>;
+export declare const updateStorageFileGroupEntryParamsType: Type<UpdateStorageFileGroupEntryParams>;
+export interface UpdateStorageFileGroupParams extends TargetModelParams {
+    readonly entries?: Maybe<UpdateStorageFileGroupEntryParams[]>;
 }
-export declare class RegenerateStorageFileGroupContentParams extends TargetModelParams {
-    /**
-     * If true, will force syncing even if the StorageFile is not flagged for a resync.
-     */
-    force?: boolean;
+export declare const updateStorageFileGroupParamsType: Type<UpdateStorageFileGroupParams>;
+export interface RegenerateStorageFileGroupContentParams extends TargetModelParams {
+    readonly force?: boolean;
 }
+export declare const regenerateStorageFileGroupContentParamsType: Type<RegenerateStorageFileGroupContentParams>;
 export interface RegenerateStorageFileGroupContentResult {
-    /**
-     * The total number of "content" StorageFiles that were flagged for processing again.
-     */
     readonly contentStorageFilesFlaggedForProcessing: number;
 }
-export declare class RegenerateAllFlaggedStorageFileGroupsContentParams {
+export interface RegenerateAllFlaggedStorageFileGroupsContentParams {
 }
+export declare const regenerateAllFlaggedStorageFileGroupsContentParamsType: Type<RegenerateAllFlaggedStorageFileGroupsContentParams>;
 export interface RegenerateAllFlaggedStorageFileGroupsContentResult {
-    /**
-     * The number of StorageFileGroups that were updated.
-     */
     readonly storageFileGroupsUpdated: number;
-    /**
-     * The number of "content" StorageFiles that were flagged for processing again.
-     */
     readonly contentStorageFilesFlaggedForProcessing: number;
 }
 /**
  * Used for initializing an uninitialized model like NotificationBox or NotificationSummary.
  */
-export declare class InitializeStorageFileModelParams extends TargetModelParams {
-    /**
-     * Whether or not to throw an error if the notification has already been sent or is being sent.
-     */
-    throwErrorIfAlreadyInitialized?: boolean;
+export interface InitializeStorageFileModelParams extends TargetModelParams {
+    readonly throwErrorIfAlreadyInitialized?: boolean;
 }
-export declare class InitializeAllApplicableStorageFileGroupsParams {
+export declare const initializeStorageFileModelParamsType: Type<InitializeStorageFileModelParams>;
+export interface InitializeAllApplicableStorageFileGroupsParams {
 }
+export declare const initializeAllApplicableStorageFileGroupsParamsType: Type<InitializeAllApplicableStorageFileGroupsParams>;
 export interface InitializeAllApplicableStorageFileGroupsResult {
     readonly storageFileGroupsVisited: number;
     readonly storageFileGroupsSucceeded: number;

package/test/index.cjs.js

@@ -3485,6 +3485,87 @@ function describeFirestoreDocumentUtilityTests(f) {
                     });
                 });
             });
+            // MARK: limitedFirestoreDocumentAccessorSnapshotCache
+            describe('limitedFirestoreDocumentAccessorSnapshotCache()', () => {
+                it('should expose the underlying accessor', () => {
+                    const accessor = f.instance.mockItemCollection.documentAccessor();
+                    const cache = firebase.limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                    expect(cache.accessor).toBe(accessor);
+                });
+                describe('getDocumentSnapshotDataPairForKey()', () => {
+                    it('should return a snapshot data pair for an existing document', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = firebase.limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const pair = await cache.getDocumentSnapshotDataPairForKey(items[0].key);
+                        expect(pair.document).toBeDefined();
+                        expect(pair.document.key).toBe(items[0].key);
+                        expect(pair.snapshot).toBeDefined();
+                        expect(pair.data).toBeDefined();
+                        expect(pair.data.id).toBe(items[0].id);
+                        expect(pair.data.key).toBe(items[0].key);
+                    });
+                    it('should return the same promise for the same key', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = firebase.limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const promise1 = cache.getDocumentSnapshotDataPairForKey(items[0].key);
+                        const promise2 = cache.getDocumentSnapshotDataPairForKey(items[0].key);
+                        expect(promise1).toBe(promise2);
+                    });
+                    it('should return undefined data for a non-existent document', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = firebase.limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const newDoc = firebase.newDocuments(accessor, 1)[0];
+                        const pair = await cache.getDocumentSnapshotDataPairForKey(newDoc.key);
+                        expect(pair.document).toBeDefined();
+                        expect(pair.data).toBeUndefined();
+                    });
+                });
+                describe('getDocumentSnapshotDataPairsForKeys()', () => {
+                    it('should return pairs for all keys in order', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = firebase.limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const keys = items.map((x) => x.key);
+                        const pairs = await cache.getDocumentSnapshotDataPairsForKeys(keys);
+                        expect(pairs.length).toBe(testDocumentCount);
+                        pairs.forEach((pair, i) => {
+                            expect(pair.document.key).toBe(items[i].key);
+                            expect(pair.data).toBeDefined();
+                            expect(pair.data.id).toBe(items[i].id);
+                        });
+                    });
+                    it('should use the cache for duplicate keys', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = firebase.limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const key = items[0].key;
+                        const [pair1] = await cache.getDocumentSnapshotDataPairsForKeys([key]);
+                        const [pair2] = await cache.getDocumentSnapshotDataPairsForKeys([key]);
+                        expect(pair1).toBe(pair2);
+                    });
+                });
+                describe('getDocumentSnapshotDataPairsWithDataForKeys()', () => {
+                    it('should return pairs for all existing documents', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = firebase.limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const keys = items.map((x) => x.key);
+                        const pairs = await cache.getDocumentSnapshotDataPairsWithDataForKeys(keys);
+                        expect(pairs.length).toBe(testDocumentCount);
+                        pairs.forEach((pair) => {
+                            expect(pair.data).toBeDefined();
+                            expect(pair.data.id).toBeDefined();
+                            expect(pair.data.key).toBeDefined();
+                        });
+                    });
+                    it('should filter out non-existent documents', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = firebase.limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const newDoc = firebase.newDocuments(accessor, 1)[0];
+                        const keys = [...items.map((x) => x.key), newDoc.key];
+                        const pairs = await cache.getDocumentSnapshotDataPairsWithDataForKeys(keys);
+                        expect(pairs.length).toBe(testDocumentCount);
+                        expect(pairs.every((p) => p.data != null)).toBe(true);
+                    });
+                });
+            });
         });
         describe('document.rxjs.ts', () => {
             // MARK: latestSnapshotsFromDocuments
@@ -3532,10 +3613,10 @@ function describeFirestoreDocumentUtilityTests(f) {
                     });
                 }));
             });
-            // MARK: latestDataFromDocuments
-            describe('latestDataFromDocuments()', () => {
+            // MARK: streamDocumentSnapshotsData
+            describe('streamDocumentSnapshotsData()', () => {
                 it('should emit data with id/key for all documents', test.callbackTest((done) => {
-                    sub.subscription = firebase.latestDataFromDocuments(items)
+                    sub.subscription = firebase.streamDocumentSnapshotsData(items)
                         .pipe(rxjs$1.first())
                         .subscribe((data) => {
                         expect(data.length).toBe(testDocumentCount);
@@ -3548,7 +3629,7 @@ function describeFirestoreDocumentUtilityTests(f) {
                     });
                 }));
                 it('should emit an empty array for empty input', test.callbackTest((done) => {
-                    sub.subscription = firebase.latestDataFromDocuments([])
+                    sub.subscription = firebase.streamDocumentSnapshotsData([])
                         .pipe(rxjs$1.first())
                         .subscribe((data) => {
                         expect(data.length).toBe(0);

package/test/index.esm.js

@@ -1,7 +1,7 @@
 import { performAsyncTasks, cachedGetter, bitwiseObjectDencoder, modelFieldConversions, isEvenNumber, arrayFactory, mapGetter, randomNumberFactory, randomFromArrayFactory, idBatchFactory, unique, waitForMs, arrayContainsDuplicateValue, useCallback, readableStreamToBuffer, SLASH_PATH_SEPARATOR } from '@dereekb/util';
 import { AbstractTestContextFixture, testContextBuilder, instanceWrapTestContextFactory, AbstractWrappedFixtureWithInstance, itShouldFail, expectFail, callbackTest } from '@dereekb/util/test';
 import { initializeTestEnvironment } from '@firebase/rules-unit-testing';
-import { firebaseStorageClientDrivers, firebaseFirestoreClientDrivers, firestoreContextFactory, firebaseStorageContextFactory, firestoreModelIdentity, snapshotConverterFunctions, firestoreBoolean, optionalFirestoreNumber, optionalFirestoreDate, optionalFirestoreArray, optionalFirestoreString, firestoreDate, firestoreBitwiseObjectMap, firestoreUniqueStringArray, firestoreNumber, firestoreString, firestoreUID, copyUserRelatedDataAccessorFactoryFunction, firestoreSubObject, AbstractFirestoreDocumentWithParent, AbstractFirestoreDocument, firebaseModelServiceFactory, grantFullAccessIfAdmin, firebaseModelsService, systemStateFirestoreCollection, allChildDocumentsUnderParent, where, makeDocuments, getDocumentSnapshotPairs, useDocumentSnapshot, useDocumentSnapshotData, firestoreIdBatchVerifierFactory, whereDocumentId, loadAllFirestoreDocumentSnapshotPairs, loadAllFirestoreDocumentSnapshot, iterateFirestoreDocumentSnapshotPairs, iterateFirestoreDocumentSnapshots, iterateFirestoreDocumentSnapshotPairBatches, iterateFirestoreDocumentSnapshotBatches, limit, orderBy, limitToLast, whereStringHasRootIdentityModelKey, whereStringValueHasPrefix, whereDateIsAfterWithSort, whereDateIsBeforeWithSort, whereDateIsOnOrAfterWithSort, whereDateIsOnOrBeforeWithSort, whereDateIsInRange, whereDateIsBetween, startAt, orderByDocumentId, startAtValue, startAfter, endAt, endAtValue, endBefore, streamFromOnSnapshot, latestSnapshotsFromDocuments, newDocuments, getDocumentSnapshots, getDocumentSnapshotPair, getDocumentSnapshotDataPair, getDocumentSnapshotDataPairs, getDocumentSnapshotDataPairsWithData, getDocumentSnapshotDataTuples, getDocumentSnapshotData, getDocumentSnapshotsData, getDataFromDocumentSnapshots, loadDocumentsForSnapshots, loadDocumentsForDocumentReferences, loadDocumentsForDocumentReferencesFromValues, loadDocumentsForKeys, loadDocumentsForKeysFromValues, loadDocumentsForIds, loadDocumentsForIdsFromValues, firestoreDocumentLoader, firestoreDocumentSnapshotPairsLoader, documentData, documentDataFunction, documentDataWithIdAndKey, setIdAndKeyFromSnapshotOnDocumentData, setIdAndKeyFromKeyIdRefOnDocumentData, firestoreModelIdFromDocument, firestoreModelIdsFromDocuments, firestoreModelKeyFromDocument, firestoreModelKeysFromDocuments, documentReferenceFromDocument, documentReferencesFromDocuments, mapLatestSnapshotsFromDocuments, latestDataFromDocuments, dataFromDocumentSnapshots, streamDocumentSnapshotDataPairs, streamDocumentSnapshotDataPairsWithData, firebaseQuerySnapshotAccumulator, firebaseQueryItemAccumulator, uploadFileWithStream, iterateStorageListFilesByEachFile } from '@dereekb/firebase';
+import { firebaseStorageClientDrivers, firebaseFirestoreClientDrivers, firestoreContextFactory, firebaseStorageContextFactory, firestoreModelIdentity, snapshotConverterFunctions, firestoreBoolean, optionalFirestoreNumber, optionalFirestoreDate, optionalFirestoreArray, optionalFirestoreString, firestoreDate, firestoreBitwiseObjectMap, firestoreUniqueStringArray, firestoreNumber, firestoreString, firestoreUID, copyUserRelatedDataAccessorFactoryFunction, firestoreSubObject, AbstractFirestoreDocumentWithParent, AbstractFirestoreDocument, firebaseModelServiceFactory, grantFullAccessIfAdmin, firebaseModelsService, systemStateFirestoreCollection, allChildDocumentsUnderParent, where, makeDocuments, getDocumentSnapshotPairs, useDocumentSnapshot, useDocumentSnapshotData, firestoreIdBatchVerifierFactory, whereDocumentId, loadAllFirestoreDocumentSnapshotPairs, loadAllFirestoreDocumentSnapshot, iterateFirestoreDocumentSnapshotPairs, iterateFirestoreDocumentSnapshots, iterateFirestoreDocumentSnapshotPairBatches, iterateFirestoreDocumentSnapshotBatches, limit, orderBy, limitToLast, whereStringHasRootIdentityModelKey, whereStringValueHasPrefix, whereDateIsAfterWithSort, whereDateIsBeforeWithSort, whereDateIsOnOrAfterWithSort, whereDateIsOnOrBeforeWithSort, whereDateIsInRange, whereDateIsBetween, startAt, orderByDocumentId, startAtValue, startAfter, endAt, endAtValue, endBefore, streamFromOnSnapshot, latestSnapshotsFromDocuments, newDocuments, getDocumentSnapshots, getDocumentSnapshotPair, getDocumentSnapshotDataPair, getDocumentSnapshotDataPairs, getDocumentSnapshotDataPairsWithData, getDocumentSnapshotDataTuples, getDocumentSnapshotData, getDocumentSnapshotsData, getDataFromDocumentSnapshots, loadDocumentsForSnapshots, loadDocumentsForDocumentReferences, loadDocumentsForDocumentReferencesFromValues, loadDocumentsForKeys, loadDocumentsForKeysFromValues, loadDocumentsForIds, loadDocumentsForIdsFromValues, firestoreDocumentLoader, firestoreDocumentSnapshotPairsLoader, documentData, documentDataFunction, documentDataWithIdAndKey, setIdAndKeyFromSnapshotOnDocumentData, setIdAndKeyFromKeyIdRefOnDocumentData, firestoreModelIdFromDocument, firestoreModelIdsFromDocuments, firestoreModelKeyFromDocument, firestoreModelKeysFromDocuments, documentReferenceFromDocument, documentReferencesFromDocuments, limitedFirestoreDocumentAccessorSnapshotCache, mapLatestSnapshotsFromDocuments, streamDocumentSnapshotsData, dataFromDocumentSnapshots, streamDocumentSnapshotDataPairs, streamDocumentSnapshotDataPairsWithData, firebaseQuerySnapshotAccumulator, firebaseQueryItemAccumulator, uploadFileWithStream, iterateStorageListFilesByEachFile } from '@dereekb/firebase';
 import { setLogLevel } from 'firebase/firestore';
 import { firstValueFrom, filter, skip, from, first, map, switchMap } from 'rxjs';
 import { SubscriptionObject, iteratorNextPageUntilPage, flattenAccumulatorResultItemArray, accumulatorCurrentPageListLoadingState, isLoadingStateFinishedLoading, accumulatorFlattenPageListLoadingState } from '@dereekb/rxjs';
@@ -3483,6 +3483,87 @@ function describeFirestoreDocumentUtilityTests(f) {
                     });
                 });
             });
+            // MARK: limitedFirestoreDocumentAccessorSnapshotCache
+            describe('limitedFirestoreDocumentAccessorSnapshotCache()', () => {
+                it('should expose the underlying accessor', () => {
+                    const accessor = f.instance.mockItemCollection.documentAccessor();
+                    const cache = limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                    expect(cache.accessor).toBe(accessor);
+                });
+                describe('getDocumentSnapshotDataPairForKey()', () => {
+                    it('should return a snapshot data pair for an existing document', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const pair = await cache.getDocumentSnapshotDataPairForKey(items[0].key);
+                        expect(pair.document).toBeDefined();
+                        expect(pair.document.key).toBe(items[0].key);
+                        expect(pair.snapshot).toBeDefined();
+                        expect(pair.data).toBeDefined();
+                        expect(pair.data.id).toBe(items[0].id);
+                        expect(pair.data.key).toBe(items[0].key);
+                    });
+                    it('should return the same promise for the same key', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const promise1 = cache.getDocumentSnapshotDataPairForKey(items[0].key);
+                        const promise2 = cache.getDocumentSnapshotDataPairForKey(items[0].key);
+                        expect(promise1).toBe(promise2);
+                    });
+                    it('should return undefined data for a non-existent document', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const newDoc = newDocuments(accessor, 1)[0];
+                        const pair = await cache.getDocumentSnapshotDataPairForKey(newDoc.key);
+                        expect(pair.document).toBeDefined();
+                        expect(pair.data).toBeUndefined();
+                    });
+                });
+                describe('getDocumentSnapshotDataPairsForKeys()', () => {
+                    it('should return pairs for all keys in order', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const keys = items.map((x) => x.key);
+                        const pairs = await cache.getDocumentSnapshotDataPairsForKeys(keys);
+                        expect(pairs.length).toBe(testDocumentCount);
+                        pairs.forEach((pair, i) => {
+                            expect(pair.document.key).toBe(items[i].key);
+                            expect(pair.data).toBeDefined();
+                            expect(pair.data.id).toBe(items[i].id);
+                        });
+                    });
+                    it('should use the cache for duplicate keys', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const key = items[0].key;
+                        const [pair1] = await cache.getDocumentSnapshotDataPairsForKeys([key]);
+                        const [pair2] = await cache.getDocumentSnapshotDataPairsForKeys([key]);
+                        expect(pair1).toBe(pair2);
+                    });
+                });
+                describe('getDocumentSnapshotDataPairsWithDataForKeys()', () => {
+                    it('should return pairs for all existing documents', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const keys = items.map((x) => x.key);
+                        const pairs = await cache.getDocumentSnapshotDataPairsWithDataForKeys(keys);
+                        expect(pairs.length).toBe(testDocumentCount);
+                        pairs.forEach((pair) => {
+                            expect(pair.data).toBeDefined();
+                            expect(pair.data.id).toBeDefined();
+                            expect(pair.data.key).toBeDefined();
+                        });
+                    });
+                    it('should filter out non-existent documents', async () => {
+                        const accessor = f.instance.mockItemCollection.documentAccessor();
+                        const cache = limitedFirestoreDocumentAccessorSnapshotCache(accessor);
+                        const newDoc = newDocuments(accessor, 1)[0];
+                        const keys = [...items.map((x) => x.key), newDoc.key];
+                        const pairs = await cache.getDocumentSnapshotDataPairsWithDataForKeys(keys);
+                        expect(pairs.length).toBe(testDocumentCount);
+                        expect(pairs.every((p) => p.data != null)).toBe(true);
+                    });
+                });
+            });
         });
         describe('document.rxjs.ts', () => {
             // MARK: latestSnapshotsFromDocuments
@@ -3530,10 +3611,10 @@ function describeFirestoreDocumentUtilityTests(f) {
                     });
                 }));
             });
-            // MARK: latestDataFromDocuments
-            describe('latestDataFromDocuments()', () => {
+            // MARK: streamDocumentSnapshotsData
+            describe('streamDocumentSnapshotsData()', () => {
                 it('should emit data with id/key for all documents', callbackTest((done) => {
-                    sub.subscription = latestDataFromDocuments(items)
+                    sub.subscription = streamDocumentSnapshotsData(items)
                         .pipe(first())
                         .subscribe((data) => {
                         expect(data.length).toBe(testDocumentCount);
@@ -3546,7 +3627,7 @@ function describeFirestoreDocumentUtilityTests(f) {
                     });
                 }));
                 it('should emit an empty array for empty input', callbackTest((done) => {
-                    sub.subscription = latestDataFromDocuments([])
+                    sub.subscription = streamDocumentSnapshotsData([])
                         .pipe(first())
                         .subscribe((data) => {
                         expect(data.length).toBe(0);

package/test/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@dereekb/firebase/test",
-  "version": "13.0.6",
+  "version": "13.1.0",
   "peerDependencies": {
-    "@dereekb/date": "13.0.6",
-    "@dereekb/firebase": "13.0.6",
-    "@dereekb/model": "13.0.6",
-    "@dereekb/rxjs": "13.0.6",
-    "@dereekb/util": "13.0.6",
+    "@dereekb/date": "13.1.0",
+    "@dereekb/firebase": "13.1.0",
+    "@dereekb/model": "13.1.0",
+    "@dereekb/rxjs": "13.1.0",
+    "@dereekb/util": "13.1.0",
     "@firebase/rules-unit-testing": "5.0.0",
     "date-fns": "^4.0.0",
     "firebase": "^12.0.0",