@aglyn/tenant-runtime 1.0.0-beta.147 → 1.0.0-beta.149

package/src/lib/get-collection-content.js

@@ -452,34 +452,6 @@ export async function scheduledPublishingPermission(hostId) {
         return ((_ref = (_b_publishedAt = b.publishedAt) == null ? void 0 : _b_publishedAt.seconds) != null ? _ref : 0) - ((_ref1 = (_a_publishedAt = a.publishedAt) == null ? void 0 : _a_publishedAt.seconds) != null ? _ref1 : 0);
     });
 }
-/**
- * How many entries are live in the whole collection (AGL-3213).
- *
- * The aggregation counts `published`, which `isLive` admits unconditionally,
- * and the live schedules are added from the docs already in hand — a due
- * schedule is still stored as `scheduled` while this runs, because
- * `flipDueEntry` writes behind the render, so neither half can count it twice.
- *
- * Falls back to the size of the read on failure. A pager that overstates by a
- * page is a page a reader can see is empty; a pager that throws is a listing
- * that does not render.
- */ async function countLiveEntries(entriesRef, docs, permission, fallback) {
-    try {
-        var _ref;
-        var _published_data;
-        const published = await entriesRef.where('status', '==', 'published').count().get();
-        const counted = Number((_ref = (_published_data = published.data()) == null ? void 0 : _published_data.count) != null ? _ref : Number.NaN);
-        if (!Number.isFinite(counted)) return fallback;
-        const liveSchedules = docs.filter((entryDoc)=>{
-            const value = entryDoc.data();
-            return value['status'] === 'scheduled' && isLive(value, permission);
-        }).length;
-        return counted + liveSchedules;
-    } catch (error) {
-        console.error(error);
-        return fallback;
-    }
-}
 /**
  * Fetches a collection's live entries (newest first), shared by the route
  * loader and the compose-time Collection entries block (AGL-551).
@@ -507,42 +479,82 @@ export async function scheduledPublishingPermission(hostId) {
     return {
         entries,
         reachedBound,
-        pendingSchedule,
-        totalLive: reachedBound ? await countLiveEntries(entriesRef, docs, permission, entries.length) : entries.length
+        pendingSchedule
     };
 }
 /**
- * One page of a listing that starts PAST the cached read (AGL-3213).
+ * One page of a listing that starts PAST the cached read (AGL-3213),
+ * addressed by the document it continues from rather than by a position
+ * (AGL-3219).
  *
  * Uncached on purpose, and it is the only read on the collection path that is.
- * The cached source exists because `/blog`, every `/blog/page/{n}`, every
- * category listing, the feed and every "Latest posts" rail want the same first
- * hundred entries (AGL-1302); a page past that bound wants ten entries nobody
- * else is asking for, and its own ISR entry is already the cache for them.
- *
- * `offset` bills the documents it skips, so page 11 of a long collection costs
- * its 110 reads per regeneration. That is the price of a listing that can be
- * read to the end, it is paid only by collections past the bound, and it is
- * paid once per page per revalidate window.
- */ async function readCollectionListingWindow(options) {
+ * The cached source exists because `/blog`, every listing address, the feed
+ * and every "Latest posts" rail want the same first hundred entries
+ * (AGL-1302); a page past that bound wants ten entries nobody else is asking
+ * for, and its own ISR entry is already the cache for them.
+ *
+ * ## Why a cursor, and not the offset this replaces
+ *
+ * `.offset(n)` asks for a POSITION, and a listing takes its inserts at the
+ * head, so every publish moves every position by one. The head pages and this
+ * read are cached under different policies and revalidated by different
+ * triggers — the publish fan-out refreshes the head eagerly and deliberately
+ * stops there — so the two sides were routinely describing the collection as
+ * it stood at two different moments, and the seam between them repeated an
+ * entry or hid one for as long as the slower side lagged. `v1.0.0-beta.147`
+ * shipped and `/changelog` showed `v1-0-0-beta-36` as both the last entry of
+ * page 10 and the first of page 11.
+ *
+ * `startAfter(doc)` asks a question whose answer does not move: what follows
+ * THIS entry. Publish a hundred entries at the head and this page returns the
+ * same ten. The seam cannot drift because there is no longer a number on
+ * either side of it to disagree about.
+ *
+ * `offset` also billed every document it skipped; a cursor bills none of them.
+ */ async function readCollectionListingPage(options) {
     try {
         const collectionDoc = await findContentCollection(options.hostId, options.collectionSlug);
         if (!collectionDoc) return null;
         const entriesRef = collectionDoc.ref.collection('entries');
-        const snapshot = await liveEntriesBase(entriesRef).orderBy('publishedAt', 'desc').orderBy('__name__', 'desc').offset(options.offset).limit(options.limit).get();
-        const due = snapshot.docs.filter((entryDoc)=>isDueScheduled(entryDoc.data()));
+        const cursorId = options.before || options.after;
+        if (!cursorId) return null;
+        // A direct get, not a `where('slug', ...)` query: the cursor IS the
+        // document name, which is the second field the read orders on, so the
+        // snapshot it needs is one document rather than an index lookup.
+        const cursorDoc = await entriesRef.doc(cursorId).get();
+        // A cursor naming a document that no longer exists — deleted, or a URL
+        // someone kept — cannot be positioned against. Null sends the caller back
+        // to the cached head, which is a page the reader can act on.
+        if (!cursorDoc.exists) return null;
+        // Backwards is the same query read the other way up, so both directions
+        // rest on an index the project already deploys: `(status, publishedAt)`
+        // exists ascending and descending both.
+        const backwards = Boolean(options.before);
+        const snapshot = await liveEntriesBase(entriesRef).orderBy('publishedAt', backwards ? 'asc' : 'desc').orderBy('__name__', backwards ? 'asc' : 'desc').startAfter(cursorDoc)// One more than the page: the extra row is the whole of "is there
+        // another page", and it replaces a `count()` over the collection.
+        .limit(options.limit + 1).get();
+        const hasMore = snapshot.docs.length > options.limit;
+        const pageDocs = snapshot.docs.slice(0, options.limit);
+        // Read backwards, the newest of the page came back last.
+        const docs = backwards ? [
+            ...pageDocs
+        ].reverse() : pageDocs;
+        const due = docs.filter((entryDoc)=>isDueScheduled(entryDoc.data()));
         const permission = due.length ? await scheduledPublishingPermission(options.hostId) : 'allowed';
         if (permission !== 'allowed') {
             for (const entryDoc of due){
                 flipDueEntry(entryDoc.ref, entryDoc.data(), permission);
             }
         }
-        const entries = toLiveEntries(snapshot.docs, permission);
+        const entries = toLiveEntries(docs, permission);
         // The byline reads `authorName`, which a record-backed author only has
         // once resolved — the cached source does this for the entries it holds,
         // and a windowed page holds entries it never saw (AGL-2486).
         await attachEntryAuthors(options.hostId, entries);
-        return entries;
+        return {
+            entries,
+            hasMore
+        };
     } catch (error) {
         // Fail open to the cached head rather than to a 500: the caller keeps
         // whatever it already had, which is a page the reader has seen before
@@ -551,6 +563,37 @@ export async function scheduledPublishingPermission(hostId) {
         return null;
     }
 }
+/**
+ * The cursor a retired `/{collection}/page/{n}` address redirects onto
+ * (AGL-3219).
+ *
+ * This is the ONE place a position is still resolved, and it is deliberately
+ * the only one: a 301 is served once, the reader lands on an address that
+ * cannot drift afterwards, and whatever the position meant at that instant is
+ * the page they would have got anyway. Everything downstream is cursors.
+ *
+ * Keys only — `select()` with no fields asks Firestore for document names and
+ * nothing else — so the skipped documents are billed at the cheapest rate the
+ * offset can be had for. Returns `''` when the position is past the end,
+ * which is a 404 rather than a redirect to nowhere.
+ */ export async function resolveCollectionPageCursor(options) {
+    const skip = (options.page - 1) * options.perPage - 1;
+    if (!Number.isFinite(skip) || skip < 0) return '';
+    try {
+        var _ref;
+        var _snapshot_docs_;
+        const collectionDoc = await findContentCollection(options.hostId, options.collectionSlug);
+        if (!collectionDoc) return '';
+        const snapshot = await collectionDoc.ref.collection('entries').where('status', 'in', [
+            'published',
+            'scheduled'
+        ]).select().orderBy('publishedAt', 'desc').orderBy('__name__', 'desc').offset(skip).limit(1).get();
+        return (_ref = (_snapshot_docs_ = snapshot.docs[0]) == null ? void 0 : _snapshot_docs_.id) != null ? _ref : '';
+    } catch (error) {
+        console.error(error);
+        return '';
+    }
+}
 /**
  * Published entries + category taxonomy for a collection resolved by slug —
  * the data source of the Collection entries block on arbitrary screens
@@ -597,11 +640,10 @@ async function readPublishedCollectionSource(options) {
                 collection: null,
                 entries: [],
                 categories: [],
-                reachedBound: false,
-                totalLive: 0
+                reachedBound: false
             };
         }
-        const { entries, reachedBound, pendingSchedule, totalLive } = await listLiveEntries(collectionDoc.ref.collection('entries'), options.hostId);
+        const { entries, reachedBound, pendingSchedule } = await listLiveEntries(collectionDoc.ref.collection('entries'), options.hostId);
         // The compose-time source feeds the Collection entries block, whose byline
         // reads `authorName` — so a record-backed author has to be resolved here
         // too, or the block prints nothing for the entries a list page shows
@@ -612,8 +654,7 @@ async function readPublishedCollectionSource(options) {
             collection: mapCollectionDoc(collectionDoc, options.collectionSlug),
             entries,
             categories: mapCollectionCategories(collectionDoc.get('categories')),
-            reachedBound,
-            totalLive
+            reachedBound
         }, pendingSchedule ? {
             pendingSchedule: true
         } : {});
@@ -623,8 +664,7 @@ async function readPublishedCollectionSource(options) {
             collection: null,
             entries: [],
             categories: [],
-            reachedBound: false,
-            totalLive: 0
+            reachedBound: false
         };
     }
 }
@@ -672,6 +712,7 @@ async function readPublishedCollectionSource(options) {
         });
     }
     if (perPage && perPage > 0) {
+        var _ref1;
         /*
      * The total is the COLLECTION's, not the read's (AGL-3213).
      *
@@ -687,15 +728,49 @@ async function readPublishedCollectionSource(options) {
      * query and a `(categoryId, status, publishedAt DESC)` index; until then
      * a category of a very large collection is capped, and says so by
      * agreeing with what it shows.
-     */ const known = Number(listing == null ? void 0 : listing.totalLive);
-        const totalEntries = !routedCategory && Number.isFinite(known) && known > data.entries.length ? known : data.entries.length;
-        const windowStart = Number(listing == null ? void 0 : listing.windowStart);
+     */ const windowStart = Number(listing == null ? void 0 : listing.windowStart);
+        const windowed = Number.isFinite(windowStart) && windowStart > 0;
+        /*
+     * The cursors, which are the pager's real answer (AGL-3219).
+     *
+     * `data.entries` is either EXACTLY this page — a cursor read — or the
+     * whole cached head, which every listing address shares and each slices
+     * its own page out of. So the page's own last entry is at the end of the
+     * array in the first case and at `page * perPage - 1` in the second, and
+     * the cursor is that entry's document id.
+     */ const pageEnd = windowed ? data.entries.length : page * perPage;
+        const last = data.entries[pageEnd - 1];
+        const first = data.entries[windowed ? 0 : (page - 1) * perPage];
+        /*
+     * Is there an older page?
+     *
+     * A cursor page KNOWS, because its read asked for one more entry than it
+     * needed and the extra row came back. The head has to reason: either it
+     * is holding more entries than this page shows, or it is holding all it
+     * could read and the read stopped at its own bound, which is the one
+     * thing `entries.length` can never tell you about the collection.
+     */ const hasMore = (_ref1 = listing == null ? void 0 : listing.cursorHasMore) != null ? _ref1 : data.entries.length > pageEnd || Boolean(listing == null ? void 0 : listing.reachedBound) && !routedCategory;
+        /*
+     * The deprecated total, stated ONLY where it can be true.
+     *
+     * A collection that fits inside one read can be counted, and a template
+     * binding `{{pagination.totalPages}}` keeps rendering the number it
+     * always did. Past the bound there is no honest total — the count and
+     * the listing were reading the collection at two different moments, which
+     * is what made the seam repeat an entry — so it is left absent rather
+     * than asserted. A routed category counts its own narrowed set, which is
+     * bounded by the same head and therefore countable.
+     */ const countable = routedCategory || !(listing == null ? void 0 : listing.reachedBound);
+        const totalEntries = countable ? data.entries.length : undefined;
         data.pagination = _extends({
             page,
             perPage,
+            nextCursor: hasMore && (last == null ? void 0 : last.$id) ? last.$id : '',
+            prevCursor: page > 1 && (first == null ? void 0 : first.$id) ? first.$id : ''
+        }, totalEntries === undefined ? {} : {
             totalEntries,
             totalPages: collectionTotalPages(totalEntries, perPage)
-        }, Number.isFinite(windowStart) && windowStart > 0 ? {
+        }, windowed ? {
             windowStart
         } : {});
     }
@@ -737,6 +812,7 @@ async function readPublishedCollectionSource(options) {
         // An ENTRY route stays where it was: it reads ONE document by slug and
         // has nothing to share.
         if (!entrySlug) {
+            var _ref, _options_after, _options_categorySlug;
             const source = await getPublishedCollectionSource({
                 hostId,
                 collectionSlug
@@ -769,30 +845,51 @@ async function readPublishedCollectionSource(options) {
        * the same head, and a window read of the whole collection would hand
        * it ten entries of which any number may belong to another category.
        */ const { page = 1, perPage } = options;
+            const cursor = ((_ref = (_options_after = options.after) != null ? _options_after : options.before) != null ? _ref : '').trim();
             let windowStart = 0;
-            if (perPage && perPage > 0 && source.reachedBound) {
-                var _options_categorySlug;
-                const offset = (page - 1) * perPage;
-                if (!((_options_categorySlug = options.categorySlug) != null ? _options_categorySlug : '').trim() && offset >= source.entries.length) {
-                    const windowed = await readCollectionListingWindow({
-                        hostId,
-                        collectionSlug,
-                        offset,
-                        limit: perPage
-                    });
-                    // Null means the window read failed, and the cached head is the
-                    // better answer than an empty page: the reader sees page 1's
-                    // entries under page N's URL rather than nothing at all.
-                    if (windowed) {
-                        data.entries = windowed;
-                        windowStart = offset;
-                    }
+            let cursored = null;
+            /*
+       * A cursor address is served by its own read (AGL-3219). Everything
+       * reachable without one comes out of the shared source, so the pages a
+       * reader actually visits stay free.
+       *
+       * Only the unfiltered listing: a category route narrows in memory over
+       * the same head, and a cursor read of the whole collection would hand it
+       * ten entries of which any number belong to another category.
+       */ if (perPage && perPage > 0 && cursor && !((_options_categorySlug = options.categorySlug) != null ? _options_categorySlug : '').trim()) {
+                cursored = await readCollectionListingPage(_extends({
+                    hostId,
+                    collectionSlug
+                }, options.before ? {
+                    before: options.before
+                } : {
+                    after: cursor
+                }, {
+                    limit: perPage
+                }));
+                // Null means the cursor read failed, or named a document that is
+                // gone. The cached head is the better answer than an empty page: the
+                // reader sees the newest entries rather than nothing at all.
+                if (cursored) {
+                    data.entries = cursored.entries;
+                    /*
+           * `entries` is now EXACTLY this page, and both windowing sites
+           * slice `[(page - 1) * perPage, …)`. Declaring the window to start
+           * at that same offset makes their subtraction come out at zero, so
+           * they take the page whole.
+           *
+           * Both sides of the subtraction are built from the same `page`, so
+           * a hand-edited counter in a URL cancels itself out: the label is
+           * wrong and the entries are still this cursor's page.
+           */ windowStart = (page - 1) * perPage;
                 }
             }
-            applyCategoryAndPagination(data, options, {
-                totalLive: source.totalLive,
-                windowStart
-            });
+            applyCategoryAndPagination(data, options, _extends({
+                windowStart,
+                reachedBound: source.reachedBound
+            }, cursored ? {
+                cursorHasMore: cursored.hasMore
+            } : {}));
             return data;
         }
         const collectionDoc = await findContentCollection(hostId, collectionSlug);