placementt-core 1.400.1200 → 1.400.1201

package/lib/__tests__/useDataViewerPaginator.test.js

@@ -478,7 +478,7 @@ describe('Suite 2 – Firestore query mode', () => {
         await (0, react_1.waitFor)(() => expect(result.current.loading).toBe('loaded'));
     });
     // ── Backward pagination ─────────────────────────────────────────────────
-    it('2.13 pageDown calls limitToLast + endBefore with startKey of current page', async () => {
+    it('2.13 pageDown reloads the previous page forward from where it started', async () => {
         mockGetDocs
             .mockResolvedValueOnce(makeSnap(makeDocs(10, 'a'))) // page 1
             .mockResolvedValueOnce(makeSnap(makeDocs(10, 'b'))) // page 2
@@ -488,11 +488,16 @@ describe('Suite 2 – Firestore query mode', () => {
         (0, react_1.act)(() => result.current.pageUp());
         await (0, react_1.waitFor)(() => expect(result.current.page).toBe(2));
         await (0, react_1.waitFor)(() => expect(result.current.loading).not.toBe(true));
+        mockLimitToLast.mockClear();
+        mockEndBefore.mockClear();
         (0, react_1.act)(() => result.current.pageDown());
         await (0, react_1.waitFor)(() => expect(result.current.page).toBe(1));
-        expect(mockLimitToLast).toHaveBeenCalledWith(10);
-        // startKey of page 2 is 'b0'
-        expect(mockEndBefore).toHaveBeenCalledWith('b0');
+        await (0, react_1.waitFor)(() => expect(mockGetDocs).toHaveBeenCalledTimes(3));
+        // Page 1 is reloaded with limit() from the start, not queried backwards.
+        expect(mockLimitToLast).not.toHaveBeenCalled();
+        expect(mockEndBefore).not.toHaveBeenCalled();
+        await (0, react_1.waitFor)(() => expect(Object.keys(result.current.tableData ?? {})[0]).toBe('a0'));
+        expect(Object.keys(result.current.tableData ?? {}).length).toBe(10);
     });
     it('2.14 pageDown from page 1 sets page to 0 (UI must guard this externally)', async () => {
         // The hook itself has no floor on page — pageDown() from page 1 sets page[0]=0.
@@ -581,7 +586,7 @@ describe('Suite 2 – Firestore query mode', () => {
         expect(keys[0]).toBe('a0');
         expect(keys[keys.length - 1]).toBe('b5');
     });
-    it('2.20 pageDown after boundary uses query B with endBefore(startKey)', async () => {
+    it('2.20 pageDown to a page spanning the boundary reloads it from query A', async () => {
         const queryA = { path: ['schools'] };
         const queryB = { path: ['employers'] };
         // Page 1: cross-boundary (4 from A, 6 from B)
@@ -595,15 +600,19 @@ describe('Suite 2 – Firestore query mode', () => {
         (0, react_1.act)(() => result.current.pageUp());
         await (0, react_1.waitFor)(() => expect(result.current.page).toBe(2));
         await (0, react_1.waitFor)(() => expect(result.current.loading).not.toBe(true));
-        // Page back: should use limitToLast + endBefore on queryB (startKey = 'c0')
+        // Page back: page 1 is reloaded forward from query A, then spills into B as it did.
+        FirestoreMod.collection.mockClear();
         mockGetDocs
-            .mockResolvedValueOnce(makeSnap(makeDocs(6, 'b')))
-            .mockResolvedValueOnce(makeSnap(makeDocs(4, 'a')));
+            .mockResolvedValueOnce(makeSnap(makeDocs(4, 'a')))
+            .mockResolvedValueOnce(makeSnap(makeDocs(6, 'b')));
         (0, react_1.act)(() => result.current.pageDown());
         await (0, react_1.waitFor)(() => expect(result.current.page).toBe(1));
-        await (0, react_1.waitFor)(() => expect(result.current.loading).not.toBe(true));
-        expect(mockLimitToLast).toHaveBeenCalled();
-        expect(mockEndBefore).toHaveBeenCalledWith('c0');
+        await (0, react_1.waitFor)(() => expect(FirestoreMod.collection.mock.calls.length).toBe(2));
+        const paths = FirestoreMod.collection.mock.calls.map((c) => c[1]);
+        expect(paths).toEqual(['schools', 'employers']);
+        const keys = Object.keys(result.current.tableData ?? {});
+        expect(keys[0]).toBe('a0');
+        expect(keys[keys.length - 1]).toBe('b5');
     });
     it('2.21 going back with sparse results fires a second getDocs call (backward spillover path)', async () => {
         // Verifies that the cursorPos-decrements-and-recurses code path fires for backward navigation.
@@ -633,6 +642,164 @@ describe('Suite 2 – Firestore query mode', () => {
         // Both queries were called during the backward pass
         expect(mockGetDocs.mock.calls.length).toBeGreaterThan(callsBeforeBack + 1);
     });
+    it('2.21d additionalEntryProcessing runs for every row at once, not one after another', async () => {
+        mockGetDocs.mockResolvedValueOnce(makeSnap(makeDocs(5, 'p')));
+        let inFlight = 0;
+        let maxInFlight = 0;
+        const processing = jest.fn(async (k, v) => {
+            inFlight += 1;
+            maxInFlight = Math.max(maxInFlight, inFlight);
+            await new Promise((r) => setTimeout(r, 10));
+            inFlight -= 1;
+            return [k, v];
+        });
+        const { result } = (0, react_1.renderHook)(() => (0, hooks_1.useDataViewerPaginator)({ view: 'table', data: [q()], queryLimit: 10, additionalEntryProcessing: processing }));
+        await (0, react_1.waitFor)(() => expect(Object.keys(result.current.tableData ?? {}).length).toBe(5));
+        expect(processing).toHaveBeenCalledTimes(5);
+        expect(maxInFlight).toBe(5);
+    });
+    it('2.21e rows keep query order when lookups finish out of order, and dropped rows stay dropped', async () => {
+        mockGetDocs.mockResolvedValueOnce(makeSnap(makeDocs(5, 'p')));
+        // Later rows finish first; p2 is dropped by processing.
+        const processing = jest.fn(async (k, v) => {
+            await new Promise((r) => setTimeout(r, 50 - Number(k.slice(1)) * 10));
+            return k === 'p2' ? undefined : [k, v];
+        });
+        const { result } = (0, react_1.renderHook)(() => (0, hooks_1.useDataViewerPaginator)({ view: 'table', data: [q()], queryLimit: 10, additionalEntryProcessing: processing }));
+        await (0, react_1.waitFor)(() => expect(Object.keys(result.current.tableData ?? {}).length).toBe(4));
+        expect(Object.keys(result.current.tableData ?? {})).toEqual(['p0', 'p1', 'p3', 'p4']);
+    });
+    it('2.21b back from an empty page after an exactly-full cross-query page restores it', async () => {
+        // The careers hub Schools table: institutes + careersInvites, exactly queryLimit rows
+        // in total, so "next" lands on an empty page. Going back used to show nothing.
+        const queryA = { path: ['schools'] };
+        const queryB = { path: ['employers'] };
+        mockGetDocs
+            .mockResolvedValueOnce(makeSnap(makeDocs(4, 'a')))
+            .mockResolvedValueOnce(makeSnap(makeDocs(6, 'b')));
+        const { result } = (0, react_1.renderHook)(() => (0, hooks_1.useDataViewerPaginator)({ view: 'table', data: [queryA, queryB], queryLimit: 10 }));
+        await (0, react_1.waitFor)(() => expect(result.current.loading).not.toBe(true));
+        const firstPage = Object.keys(result.current.tableData ?? {});
+        expect(firstPage.length).toBe(10);
+        mockGetDocs.mockResolvedValueOnce(makeSnap([]));
+        (0, react_1.act)(() => result.current.pageUp());
+        await (0, react_1.waitFor)(() => expect(result.current.page).toBe(2));
+        await (0, react_1.waitFor)(() => expect(result.current.loading).toBe('loaded'));
+        expect(Object.keys(result.current.tableData ?? {}).length).toBe(0);
+        mockGetDocs
+            .mockResolvedValueOnce(makeSnap(makeDocs(4, 'a')))
+            .mockResolvedValueOnce(makeSnap(makeDocs(6, 'b')));
+        (0, react_1.act)(() => result.current.pageDown());
+        await (0, react_1.waitFor)(() => expect(result.current.page).toBe(1));
+        await (0, react_1.waitFor)(() => expect(mockGetDocs).toHaveBeenCalledTimes(5));
+        await (0, react_1.waitFor)(() => expect(Object.keys(result.current.tableData ?? {})).toEqual(firstPage));
+    });
+    it('2.21c back from page 3 to a page 2 that spans both queries', async () => {
+        const queryA = { path: ['schools'] };
+        const queryB = { path: ['employers'] };
+        mockGetDocs.mockResolvedValueOnce(makeSnap(makeDocs(10, 'a')));
+        const { result } = (0, react_1.renderHook)(() => (0, hooks_1.useDataViewerPaginator)({ view: 'table', data: [queryA, queryB], queryLimit: 10 }));
+        await (0, react_1.waitFor)(() => expect(result.current.loading).not.toBe(true));
+        mockGetDocs
+            .mockResolvedValueOnce(makeSnap(makeDocs(3, 'a2-')))
+            .mockResolvedValueOnce(makeSnap(makeDocs(7, 'b')));
+        (0, react_1.act)(() => result.current.pageUp());
+        await (0, react_1.waitFor)(() => expect(result.current.page).toBe(2));
+        // Page 1's rows stay up while page 2 loads, so wait for page 2's own rows.
+        await (0, react_1.waitFor)(() => expect(Object.keys(result.current.tableData ?? {})[0]).toBe('a2-0'));
+        const secondPage = Object.keys(result.current.tableData ?? {});
+        expect(secondPage.length).toBe(10);
+        mockGetDocs.mockResolvedValueOnce(makeSnap(makeDocs(2, 'b3-')));
+        (0, react_1.act)(() => result.current.pageUp());
+        await (0, react_1.waitFor)(() => expect(result.current.page).toBe(3));
+        await (0, react_1.waitFor)(() => expect(result.current.loading).toBe('loaded'));
+        mockStartAfter.mockClear();
+        mockGetDocs
+            .mockResolvedValueOnce(makeSnap(makeDocs(3, 'a2-')))
+            .mockResolvedValueOnce(makeSnap(makeDocs(7, 'b')));
+        (0, react_1.act)(() => result.current.pageDown());
+        await (0, react_1.waitFor)(() => expect(result.current.page).toBe(2));
+        // Reloaded from where page 2 started: after the last row of page 1.
+        await (0, react_1.waitFor)(() => expect(mockStartAfter).toHaveBeenCalledWith('a9'));
+        await (0, react_1.waitFor)(() => expect(Object.keys(result.current.tableData ?? {})).toEqual(secondPage));
+    });
+    it('2.21f a revisited page shows its cached rows at once, then the refreshed rows', async () => {
+        mockGetDocs
+            .mockResolvedValueOnce(makeSnap(makeDocs(10, 'a')))
+            .mockResolvedValueOnce(makeSnap(makeDocs(10, 'b')));
+        const { result } = (0, react_1.renderHook)(() => (0, hooks_1.useDataViewerPaginator)({ view: 'table', data: [q()], queryLimit: 10 }));
+        await (0, react_1.waitFor)(() => expect(result.current.loading).not.toBe(true));
+        (0, react_1.act)(() => result.current.pageUp());
+        await (0, react_1.waitFor)(() => expect(Object.keys(result.current.tableData ?? {})[0]).toBe('b0'));
+        // Hold the refresh of page 1 so the cached rows can be seen first.
+        let release = () => undefined;
+        mockGetDocs.mockImplementationOnce(() => new Promise((r) => { release = r; }));
+        (0, react_1.act)(() => result.current.pageDown());
+        await (0, react_1.waitFor)(() => expect(result.current.page).toBe(1));
+        await (0, react_1.waitFor)(() => expect(Object.keys(result.current.tableData ?? {})[0]).toBe('a0'));
+        expect(result.current.loading).not.toBe(true); // Not flagged as loading while refreshing.
+        expect(result.current.tableData?.a0?.val).toBe(0);
+        // The refresh lands with a changed value on the first row.
+        await (0, react_1.act)(async () => release(makeSnap([makeDoc('a0', { val: 'updated' }), ...makeDocs(10, 'a').slice(1)])));
+        await (0, react_1.waitFor)(() => expect(result.current.tableData?.a0?.val).toBe('updated'));
+        expect(Object.keys(result.current.tableData ?? {}).length).toBe(10);
+    });
+    it('2.21g a slow load for a page already left (e.g. reset mid-load) does not overwrite the current page', async () => {
+        mockGetDocs.mockResolvedValueOnce(makeSnap(makeDocs(10, 'a')));
+        const { result } = (0, react_1.renderHook)(() => (0, hooks_1.useDataViewerPaginator)({ view: 'table', data: [q()], queryLimit: 10 }));
+        await (0, react_1.waitFor)(() => expect(result.current.loading).not.toBe(true));
+        // Page 2 is slow; a reset (filter/search change) takes the table back to page 1 first.
+        let releasePage2 = () => undefined;
+        mockGetDocs.mockImplementationOnce(() => new Promise((r) => { releasePage2 = r; }));
+        (0, react_1.act)(() => result.current.pageUp());
+        await (0, react_1.waitFor)(() => expect(result.current.page).toBe(2));
+        mockGetDocs.mockResolvedValueOnce(makeSnap(makeDocs(10, 'fresh')));
+        (0, react_1.act)(() => result.current.reset());
+        await (0, react_1.waitFor)(() => expect(result.current.page).toBe(1));
+        await (0, react_1.waitFor)(() => expect(Object.keys(result.current.tableData ?? {})[0]).toBe('fresh0'));
+        await (0, react_1.act)(async () => releasePage2(makeSnap(makeDocs(10, 'late'))));
+        await new Promise((r) => setTimeout(r, 20));
+        expect(Object.keys(result.current.tableData ?? {})[0]).toBe('fresh0');
+    });
+    it('2.21i next and back are ignored while a page is still loading', async () => {
+        mockGetDocs.mockResolvedValueOnce(makeSnap(makeDocs(10, 'a')));
+        const { result } = (0, react_1.renderHook)(() => (0, hooks_1.useDataViewerPaginator)({ view: 'table', data: [q()], queryLimit: 10 }));
+        await (0, react_1.waitFor)(() => expect(result.current.loading).not.toBe(true));
+        let releasePage2 = () => undefined;
+        mockGetDocs.mockImplementationOnce(() => new Promise((r) => { releasePage2 = r; }));
+        (0, react_1.act)(() => result.current.pageUp());
+        await (0, react_1.waitFor)(() => expect(result.current.page).toBe(2));
+        expect(result.current.loading).toBe(true);
+        (0, react_1.act)(() => result.current.pageUp());
+        (0, react_1.act)(() => result.current.pageDown());
+        expect(result.current.page).toBe(2);
+        expect(mockGetDocs).toHaveBeenCalledTimes(2);
+        await (0, react_1.act)(async () => releasePage2(makeSnap(makeDocs(10, 'b'))));
+        await (0, react_1.waitFor)(() => expect(result.current.loading).not.toBe(true));
+        // Once loaded, next starts after the last row of page 2.
+        mockStartAfter.mockClear();
+        mockGetDocs.mockResolvedValueOnce(makeSnap(makeDocs(10, 'c')));
+        (0, react_1.act)(() => result.current.pageUp());
+        await (0, react_1.waitFor)(() => expect(result.current.page).toBe(3));
+        expect(mockStartAfter).toHaveBeenCalledWith('b9');
+    });
+    it('2.21h reset clears the page cache', async () => {
+        mockGetDocs
+            .mockResolvedValueOnce(makeSnap(makeDocs(10, 'a')))
+            .mockResolvedValueOnce(makeSnap(makeDocs(10, 'b')));
+        const { result } = (0, react_1.renderHook)(() => (0, hooks_1.useDataViewerPaginator)({ view: 'table', data: [q()], queryLimit: 10 }));
+        await (0, react_1.waitFor)(() => expect(result.current.loading).not.toBe(true));
+        (0, react_1.act)(() => result.current.pageUp());
+        await (0, react_1.waitFor)(() => expect(Object.keys(result.current.tableData ?? {})[0]).toBe('b0'));
+        // After a reset, page 1 must come from Firestore, not the old cache.
+        let release = () => undefined;
+        mockGetDocs.mockImplementationOnce(() => new Promise((r) => { release = r; }));
+        (0, react_1.act)(() => result.current.reset());
+        await (0, react_1.waitFor)(() => expect(result.current.page).toBe(1));
+        expect(Object.keys(result.current.tableData ?? {}).length).toBe(0);
+        await (0, react_1.act)(async () => release(makeSnap(makeDocs(10, 'fresh'))));
+        await (0, react_1.waitFor)(() => expect(Object.keys(result.current.tableData ?? {})[0]).toBe('fresh0'));
+    });
     it('2.22 three queries: stitch across Q0→Q1→Q2 over two page loads', async () => {
         const q0 = { path: ['c0'] };
         const q1 = { path: ['c1'] };