@aglyn/tenant-runtime 1.0.0-beta.198 → 1.0.0-beta.200

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

@@ -32,12 +32,13 @@ import { PUBLISHED_SITE_DATA_TTL_SECONDS, tenantDataTag, withRenderCache } from
  * cache already holding exactly that.
  *
  * The other half of that argument was real and is answered rather than
- * dropped: `flipDueEntry` is a write, and nothing else publishes a content
- * entry, so a cache that stored a collection with a schedule still pending
- * would suppress the render that publishes it. `getPublishedCollectionSource`
- * therefore declines to STORE exactly those collections — see its `store`
- * predicate — which leaves scheduled publishing on the render window it has
- * always been on, and puts everything else on this TTL.
+ * dropped: `flipDueEntry` is a write, and a render is the backstop that
+ * publishes a content entry when the `apply-entry-schedules` beat has not
+ * (AGL-3340), so a cache that stored a collection with a schedule still
+ * pending would suppress the render that publishes it.
+ * `getPublishedCollectionSource` therefore declines to STORE exactly those
+ * collections — see its `store` predicate — which keeps that backstop on the
+ * render window, and puts everything else on this TTL.
  */ const COLLECTION_SOURCE_TTL_SECONDS = PUBLISHED_SITE_DATA_TTL_SECONDS;
 /**
  * Resolve a public content-collection slug (AGL-954). Commerce's product
@@ -208,12 +209,30 @@ import { PUBLISHED_SITE_DATA_TTL_SECONDS, tenantDataTag, withRenderCache } from
 }
 /**
  * A scheduled entry still waiting on its time: not due yet, and not refused.
- * Nothing but a render publishes a content entry, so a cache that stored a
- * read holding one would withhold the render that notices it come due — see
- * {@link LiveEntriesRead.pendingSchedule}.
+ * A render is the backstop that publishes a content entry the beat has not
+ * reached, so a cache that stored a read holding one would withhold the render
+ * that notices it come due — see {@link LiveEntriesRead.pendingSchedule}.
  */ export function isPendingScheduled(value) {
     return value['status'] === 'scheduled' && !scheduleAlreadyRefused(value) && !isDueScheduled(value);
 }
+/**
+ * When this entry's schedule comes due, in epoch ms — or null when it holds
+ * no schedule to act on: not `scheduled`, already refused, or carrying no
+ * `publishAt` (AGL-3340).
+ *
+ * The beat orders its probe by this instant. A refused schedule keeps
+ * `status: 'scheduled'` forever (see {@link ENTRY_SCHEDULE_SKIPPED}), so
+ * reading one as due would make every beat re-probe for work that will never
+ * be done. Seconds, like {@link isDueScheduled}, so the two agree about the
+ * instant an entry comes due.
+ */ export function entryScheduleDueAtMs(value) {
+    var _value_publishAt;
+    if (value['status'] !== 'scheduled' || scheduleAlreadyRefused(value)) {
+        return null;
+    }
+    const seconds = (_value_publishAt = value['publishAt']) == null ? void 0 : _value_publishAt.seconds;
+    return typeof seconds === 'number' ? seconds * 1000 : null;
+}
 export async function scheduledPublishingPermission(hostId) {
     try {
         var _this;
@@ -232,7 +251,10 @@ export async function scheduledPublishingPermission(hostId) {
 /**
  * Scheduled entries (AGL-123) go live lazily like AGL-61: a due
  * `publishAt` counts as published for this render, and the doc is flipped
- * to `published` fail-open so the state becomes durable.
+ * to `published` fail-open so the state becomes durable. The tenant's
+ * `apply-entry-schedules` beat makes the same flip at the entry's time and
+ * drops the pages that list it (AGL-3340); this render-time half stays as the
+ * backstop for a beat that is down or has not reached the entry yet.
  *
  * PLAN GATE (AGL-471). `scheduledPublishing` is a Business entitlement, and
  * until now nothing on the entry path checked it: the console let any plan
@@ -263,28 +285,54 @@ export async function scheduledPublishingPermission(hostId) {
  * subsequent render.
  *
  * Both writes fail open: an error leaves today's state, and the next render
- * retries.
- */ function flipDueEntry(docRef, value, permission) {
-    if (value['status'] !== 'scheduled') return;
-    if (scheduleAlreadyRefused(value)) return;
+ * retries. A render does not wait for them (`void`); the beat does, because
+ * it drops pages only for a flip that landed.
+ *
+ * `precondition` is the beat's: it read the entry some milliseconds earlier,
+ * and an author rescheduling it in between must win. A render passes none —
+ * it writes exactly what it just rendered.
+ */ async function flipDueEntry(docRef, value, permission, precondition) {
+    if (value['status'] !== 'scheduled') return 'unchanged';
+    if (scheduleAlreadyRefused(value)) return 'unchanged';
     // `unresolved` writes NOTHING. It withholds this render and leaves the
     // schedule exactly as it found it, so a later render can still publish it.
-    if (permission === 'unresolved') return;
-    if (permission === 'refused') {
-        if (!isDueScheduled(value)) return;
-        docRef.update({
-            scheduleStatus: ENTRY_SCHEDULE_SKIPPED
-        }).catch((error)=>console.error(error));
-        return;
-    }
-    // The console's sort key follows the flip (AGL-3323). It already held
-    // `publishAt` while the entry waited, and `publishedAt` takes that same
-    // instant, so the entry keeps its place in the console's Published order.
-    docRef.update({
+    if (permission === 'unresolved') return 'unchanged';
+    if (!isDueScheduled(value)) return 'unchanged';
+    const update = permission === 'refused' ? {
+        scheduleStatus: ENTRY_SCHEDULE_SKIPPED
+    } : // `publishAt` while the entry waited, and `publishedAt` takes that
+    // same instant, so the entry keeps its place in the console's
+    // Published order.
+    {
         status: 'published',
         publishedAt: value['publishAt'],
         [ENTRY_PUBLISH_SORT_FIELD]: value['publishAt']
-    }).catch((error)=>console.error(error));
+    };
+    try {
+        if (precondition) await docRef.update(update, precondition);
+        else await docRef.update(update);
+        return permission === 'refused' ? 'refused' : 'published';
+    } catch (error) {
+        console.error(error);
+        return 'failed';
+    }
+}
+/**
+ * Apply one due entry schedule outside a render (AGL-3340) — the executor the
+ * `apply-entry-schedules` beat runs, and the same one a render runs, so the
+ * two cannot come to disagree about the plan gate or the fields a flip
+ * writes.
+ *
+ * Asks the plan only for an entry that is actually due, as every render path
+ * does. Guarded on the snapshot's own `updateTime`: a schedule edited after
+ * the beat read it is left for the next beat, which reads it fresh.
+ */ export async function applyDueEntrySchedule(options) {
+    const value = options.entry.data();
+    if (!value || !isDueScheduled(value)) return 'unchanged';
+    const permission = await scheduledPublishingPermission(options.hostId);
+    return flipDueEntry(options.entry.ref, value, permission, options.entry.updateTime ? {
+        lastUpdateTime: options.entry.updateTime
+    } : undefined);
 }
 /**
  * The fields a LISTING read of an entry needs — the field mask on the query
@@ -340,9 +388,9 @@ export async function scheduledPublishingPermission(hostId) {
  *
  * Read by its own query rather than taken from the dated page below, because
  * a schedule is invisible to that page: scheduling writes `publishAt` and
- * never `publishedAt`, and `flipDueEntry` during a render is the only thing
- * that publishes one. A schedule the read misses is a post that never goes
- * out. The set is small by nature — a hundred pending schedules on one
+ * never `publishedAt`, and when the beat has not reached one, `flipDueEntry`
+ * during a render is the only thing that publishes it. A schedule the read
+ * misses is then a post that does not go out. The set is small by nature — a hundred pending schedules on one
  * collection is already an unusual editorial calendar.
  */ const SCHEDULED_SOURCE_MAX = 100;
 /** Everything a public listing may show, before any ordering. */ function liveEntriesBase(entriesRef) {
@@ -444,7 +492,7 @@ export async function scheduledPublishingPermission(hostId) {
     return docs.filter((entryDoc)=>isLive(entryDoc.data(), permission)).map((entryDoc)=>{
         var _value_title, _value_slug, _value_publishedAt, _value_publishedAt1;
         const value = entryDoc.data();
-        flipDueEntry(entryDoc.ref, value, permission);
+        void flipDueEntry(entryDoc.ref, value, permission);
         return _extends({
             $id: entryDoc.id,
             title: (_value_title = value['title']) != null ? _value_title : entryDoc.id,
@@ -478,7 +526,7 @@ export async function scheduledPublishingPermission(hostId) {
     // re-reading the org on each one.
     if (permission !== 'allowed') {
         for (const entryDoc of due){
-            flipDueEntry(entryDoc.ref, entryDoc.data(), permission);
+            void flipDueEntry(entryDoc.ref, entryDoc.data(), permission);
         }
     }
     // Measured on the RAW docs, before the liveness filter (AGL-1516): a
@@ -553,7 +601,7 @@ export async function scheduledPublishingPermission(hostId) {
         const permission = due.length ? await scheduledPublishingPermission(options.hostId) : 'allowed';
         if (permission !== 'allowed') {
             for (const entryDoc of due){
-                flipDueEntry(entryDoc.ref, entryDoc.data(), permission);
+                void flipDueEntry(entryDoc.ref, entryDoc.data(), permission);
             }
         }
         const entries = toLiveEntries(docs, permission);
@@ -624,13 +672,13 @@ export async function scheduledPublishingPermission(hostId) {
             read: ()=>readPublishedCollectionSource(options),
             // A collection with a schedule still pending is SERVED but not STORED.
             //
-            // No beat publishes a content entry — `flipDueEntry` during a render is
-            // the whole mechanism — so storing this source would suppress the very
-            // renders that would have noticed the entry coming due, and the post
-            // would wait out the TTL rather than land at its time. Declining to
-            // store leaves those collections exactly as uncached as they were
-            // before this cache existed, which is the only cost this cache is not
-            // allowed to reduce.
+            // The beat publishes a due entry and drops this tag (AGL-3340); when
+            // the beat is down, `flipDueEntry` during a render is what publishes
+            // it, so storing this source would suppress the very renders that would
+            // have noticed the entry coming due, and the post would wait out the
+            // TTL rather than land at its time. Declining to store leaves those
+            // collections exactly as uncached as they were before this cache
+            // existed, which is the only cost this cache is not allowed to reduce.
             //
             // Also refuses a collection that resolved to nothing, for the reason
             // `withRenderCache` states about negatives generally: a slug that
@@ -912,19 +960,19 @@ async function readPublishedCollectionSource(options) {
         // something is due, and record the refusal on its own pass because a
         // refused entry never becomes the `entryDoc` below (AGL-471).
         //
-        // A PREVIEW RENDER SKIPS BOTH WRITES (AGL-3205). `flipDueEntry` is the
-        // entire publishing mechanism for a content entry, and it is a mechanism
-        // that belongs to the PUBLIC render: a preview is one person looking at
-        // one post through a link, and it must not be able to publish it, nor to
-        // burn its schedule with the terminal refusal marker. Skipping the writes
-        // costs nothing — the next public render asks the same questions and
-        // writes the same answers — and it is what keeps "nothing but a render
-        // publishes a content entry" true of renders anybody can reach.
+        // A PREVIEW RENDER SKIPS BOTH WRITES (AGL-3205). `flipDueEntry` is how a
+        // content entry is published — by the beat, or by a render as its
+        // backstop — and the render half belongs to the PUBLIC render: a preview
+        // is one person looking at one post through a link, and it must not be
+        // able to publish it, nor to burn its schedule with the terminal refusal
+        // marker. Skipping the writes costs nothing — the beat or the next public
+        // render asks the same questions and writes the same answers — and it is
+        // what keeps a preview link from publishing anything.
         const dueHere = entryQuery.docs.filter((docSnapshot)=>isDueScheduled(docSnapshot.data()));
         const permission = dueHere.length ? await scheduledPublishingPermission(hostId) : 'allowed';
         if (permission !== 'allowed' && !preview) {
             for (const docSnapshot of dueHere){
-                flipDueEntry(docSnapshot.ref, docSnapshot.data(), permission);
+                void flipDueEntry(docSnapshot.ref, docSnapshot.data(), permission);
             }
         }
         /**
@@ -944,7 +992,7 @@ async function readPublishedCollectionSource(options) {
         if (entryDoc) {
             var _value_title, _value_body, _value_publishedAt, _value_publishedAt1;
             const value = entryDoc.data();
-            if (!preview) flipDueEntry(entryDoc.ref, value, permission);
+            if (!preview) void flipDueEntry(entryDoc.ref, value, permission);
             if (preview && !isLive(value, permission)) {
                 var _value_status;
                 var _value_publishAt;