pg-boss 12.33.6 → 12.33.7

package/dist/plans.js

@@ -1961,8 +1961,8 @@ export function insertJobs(schema, { table, name, returnId = true, notify = fals
     // When notify is enabled we always RETURN start_after so the wrapper below can gate
     // the NOTIFY on immediate availability, regardless of whether the caller wants ids.
     const returning = notify ? 'RETURNING id, start_after' : returnId ? 'RETURNING id' : '';
-    // A caller that knows the slot names it outright: the cron pass files a rule occurrence in the
-    // slot the occurrence falls in, and an offset off now() cannot pin that, since now() here is
+    // A caller that knows the slot names it outright: the cron pass files an occurrence in the slot
+    // the occurrence falls in, and an offset off now() cannot pin that, since now() here is
     // insert time. Only in the statement the pass asks for, because insert() stringifies caller
     // objects straight into the recordset below, so a column declared for everyone would be a live,
     // undeclared and unvalidated option on the public path, where a bad value surfaces as a raw

package/dist/timekeeper.d.ts

@@ -127,9 +127,13 @@ declare class Timekeeper extends EventEmitter implements types.EventsMixin {
      * job is what keeps the passes that follow from sending it a second time.
      *
      * The window rather than its most recent point, since a rule can put two occurrences inside it
-     * and a read that answers with one of them drops the other. A cron expression cannot: its finest
-     * resolution is a second, and consecutive occurrences a second apart share a throttle slot, so
-     * only the most recent one can produce a job.
+     * and a read that answers with one of them drops the other. A cron expression needs only the
+     * most recent one, although two of its occurrences either side of a minute fall in slots of
+     * their own: the minutes an expression matches are a minute apart at the closest, and passes run
+     * closer together than the window is wide, so one lands while a matching minute's first
+     * occurrence is still due and before any later minute has come round. It reads an occurrence of
+     * that minute and files the job under it. An occurrence this read passes over falls in a minute
+     * a pass before it answered for.
      */
     private readOccurrences;
     private reportSendItError;

package/dist/timekeeper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timekeeper.d.ts","sourceRoot":"","sources":["../src/timekeeper.ts"],"names":[],"mappings":"AAEA,OAAO,YAAY,MAAM,aAAa,CAAA;AAItC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAKvC,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAGnC,eAAO,MAAM,MAAM;;CAElB,CAAA;AAwBD,kGAAkG;AAClG,eAAO,MAAM,iBAAiB,OAAO,CAAA;AA6MrC,cAAM,UAAW,SAAQ,YAAa,YAAW,KAAK,CAAC,WAAW;IAChE,EAAE,EAAE,KAAK,CAAC,SAAS,CAAA;IACnB,MAAM,EAAE,KAAK,CAAC,0BAA0B,CAAA;IACxC,OAAO,EAAE,OAAO,CAAA;IAEhB,OAAO,CAAC,OAAO,CAAO;IACtB,OAAO,CAAC,gBAAgB,CAA+B;IACvD,OAAO,CAAC,gBAAgB,CAAqC;IAC7D,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,aAAa,CAAQ;IAS7B,OAAO,CAAC,eAAe,CAAoB;IAE3C,SAAS,SAAI;IACb,MAAM;;;;MAAS;gBAEF,EAAE,EAAE,KAAK,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,0BAA0B;IAQ5F,IAAI,YAAY,IAAK,OAAO,CAE3B;IAMD,OAAO,KAAK,YAAY,GAEvB;IAED,OAAO,KAAK,cAAc,GASzB;IAEK,KAAK;IA4BL,IAAI;IAmCV,OAAO,CAAC,mBAAmB;IAUrB,cAAc;IA8Cd,MAAM;IAgDZ;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,eAAe;IAQvB;;;;;OAKG;IACG,IAAI,CAAE,WAAW,GAAE,OAAc;IA0IvC,YAAY,CAAE,UAAU,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,GAAE,KAAK,CAAC,YAAwC;IAIlG;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,cAAc;IAgBtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,OAAO,CAAC,gBAAgB;IAgBxB;;;;;;;OAOG;IACH,OAAO,CAAC,sBAAsB;IAgB9B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,eAAe;IAwBvB,OAAO,CAAC,iBAAiB;YAQX,QAAQ;YAsDR,aAAa;IAerB,YAAY,CAAE,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;IAiBrE,WAAW,CAAE,IAAI,EAAE,MAAM,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC;IAe1E;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;IAYxB;;;;;;;;;;;;;;;;OAgBG;IACH,eAAe,CAAE,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,KAAK,CAAC,sBAA2B,GAAG,IAAI,EAAE;IA0C5E,QAAQ,CAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,GAAE,KAAK,CAAC,eAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;IA6CzG,UAAU,CAAE,IAAI,EAAE,MAAM,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,CAAC;CAIzD;AAED,eAAe,UAAU,CAAA"}
+{"version":3,"file":"timekeeper.d.ts","sourceRoot":"","sources":["../src/timekeeper.ts"],"names":[],"mappings":"AAEA,OAAO,YAAY,MAAM,aAAa,CAAA;AAItC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAKvC,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAGnC,eAAO,MAAM,MAAM;;CAElB,CAAA;AAwBD,kGAAkG;AAClG,eAAO,MAAM,iBAAiB,OAAO,CAAA;AA8MrC,cAAM,UAAW,SAAQ,YAAa,YAAW,KAAK,CAAC,WAAW;IAChE,EAAE,EAAE,KAAK,CAAC,SAAS,CAAA;IACnB,MAAM,EAAE,KAAK,CAAC,0BAA0B,CAAA;IACxC,OAAO,EAAE,OAAO,CAAA;IAEhB,OAAO,CAAC,OAAO,CAAO;IACtB,OAAO,CAAC,gBAAgB,CAA+B;IACvD,OAAO,CAAC,gBAAgB,CAAqC;IAC7D,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,aAAa,CAAQ;IAS7B,OAAO,CAAC,eAAe,CAAoB;IAE3C,SAAS,SAAI;IACb,MAAM;;;;MAAS;gBAEF,EAAE,EAAE,KAAK,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,0BAA0B;IAQ5F,IAAI,YAAY,IAAK,OAAO,CAE3B;IAMD,OAAO,KAAK,YAAY,GAEvB;IAED,OAAO,KAAK,cAAc,GASzB;IAEK,KAAK;IA4BL,IAAI;IAmCV,OAAO,CAAC,mBAAmB;IAUrB,cAAc;IA8Cd,MAAM;IAgDZ;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,eAAe;IAQvB;;;;;OAKG;IACG,IAAI,CAAE,WAAW,GAAE,OAAc;IAoIvC,YAAY,CAAE,UAAU,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,GAAE,KAAK,CAAC,YAAwC;IAIlG;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,cAAc;IAgBtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,OAAO,CAAC,gBAAgB;IAgBxB;;;;;;;OAOG;IACH,OAAO,CAAC,sBAAsB;IAgB9B;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,eAAe;IAwBvB,OAAO,CAAC,iBAAiB;YAQX,QAAQ;YAsDR,aAAa;IAerB,YAAY,CAAE,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;IAiBrE,WAAW,CAAE,IAAI,EAAE,MAAM,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC;IAe1E;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;IAYxB;;;;;;;;;;;;;;;;OAgBG;IACH,eAAe,CAAE,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,KAAK,CAAC,sBAA2B,GAAG,IAAI,EAAE;IA0C5E,QAAQ,CAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,GAAE,KAAK,CAAC,eAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;IA6CzG,UAAU,CAAE,IAAI,EAAE,MAAM,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,CAAC;CAIzD;AAED,eAAe,UAAU,CAAA"}

package/dist/timekeeper.js

@@ -469,46 +469,41 @@ class Timekeeper extends EventEmitter {
             // The payload carries the schedule's key beside its queue name, so the send-it handler knows
             // which row an occurrence came from and can record the job it produced.
             const forwarded = { data: { name, key, data, options }, singletonKey: occurrenceKey(name, key) };
-            // A recurrence rule can put an occurrence anywhere in the minute, and a slot measured from
-            // insert time would then straddle it: two passes on either side of a slot boundary both find
-            // the occurrence inside the window and file it in a slot of their own, sending it twice. So a
-            // rule occurrence names the slot it falls in outright. An offset from the insert's own now()
-            // would not pin it: everything between reading the clock here and the insert committing
-            // counts towards the shifted instant, which lands in the next slot whenever that adds up to a
-            // boundary crossing.
+            // An occurrence can fall anywhere in the minute, a rule wherever it says and a cron
+            // expression on the second its sixth placeholder names, and a slot measured from insert
+            // time would then straddle it: two passes on either side of a slot boundary both find the occurrence
+            // inside the window and file it in a slot of their own, sending it twice. So an occurrence
+            // names the slot it falls in outright. An offset from the insert's own now() would not pin
+            // it: everything between reading the clock here and the insert committing counts towards
+            // the shifted instant, which lands in the next slot whenever that adds up to a boundary
+            // crossing.
+            //
+            // An instance on a release that files a cron occurrence from insert time agrees with this
+            // slot wherever that insert lands in the occurrence's own minute, and disagrees only where
+            // it would already have sent the occurrence twice, so a rolling upgrade sends no more jobs
+            // than the older release does alone.
             //
             // A missed occurrence names its slot for that reason and one more: it is older than the
             // window, so a slot off insert time would file it in the slot the pass runs in, where it
-            // would collide with the cron job filed below and be dropped. The slot it names is older
-            // than the one insert time computes, so it cannot.
+            // would collide with the job of the occurrence due now and be dropped. The slot it names is
+            // older than the one insert time computes, so it cannot.
             //
             // One job per slot rather than one per occurrence, which is the resolution the docs promise:
-            // a rule finer than a slot sends a job a slot, and two occurrences inside one window that
-            // fall in slots of their own each send.
+            // an expression finer than a slot sends a job a slot, and two occurrences inside one window
+            // that fall in slots of their own each send.
             const slots = new Set();
             if (missed !== null) {
                 slots.add(throttleSlot(missed));
             }
-            if (due.kind === plans.SCHEDULE_KINDS.rrule) {
-                // Through the set the missed occurrences went through, since the window's lower bound falls
-                // inside a slot rather than on one: an occurrence on the bound is missed, one a millisecond
-                // later is due, and both belong to the same slot and so to the same job.
-                for (const occurrence of due.occurrences) {
-                    slots.add(throttleSlot(occurrence));
-                }
+            // Through the set the missed occurrence went through, since the window's lower bound falls
+            // inside a slot rather than on one: an occurrence on the bound is missed, one a millisecond
+            // later is due, and both belong to the same slot and so to the same job.
+            for (const occurrence of due.occurrences) {
+                slots.add(throttleSlot(occurrence));
             }
             for (const slot of slots) {
                 scheduled.push({ ...forwarded, data: { ...forwarded.data, slot }, __singletonSlot: slot });
             }
-            // Anything not read as a rule is read as cron, which is what a row carrying no kind at all
-            // means: the column defaults to cron, and a reader that cannot see it reads the row the way
-            // every release before the column did.
-            if (due.kind !== plans.SCHEDULE_KINDS.rrule && due.occurrences.length > 0) {
-                // A cron occurrence keeps the slot every release has always filed it in, since an instance
-                // still running an older one during a rolling upgrade computes that slot and nothing else,
-                // and a slot the two disagree on collapses nothing.
-                scheduled.push({ ...forwarded, singletonSeconds: OCCURRENCE_WINDOW_SECONDS });
-            }
         }
         this.warnedSchedules = stillBroken;
         if (scheduled.length > 0 && !this.stopped) {
@@ -624,9 +619,13 @@ class Timekeeper extends EventEmitter {
      * job is what keeps the passes that follow from sending it a second time.
      *
      * The window rather than its most recent point, since a rule can put two occurrences inside it
-     * and a read that answers with one of them drops the other. A cron expression cannot: its finest
-     * resolution is a second, and consecutive occurrences a second apart share a throttle slot, so
-     * only the most recent one can produce a job.
+     * and a read that answers with one of them drops the other. A cron expression needs only the
+     * most recent one, although two of its occurrences either side of a minute fall in slots of
+     * their own: the minutes an expression matches are a minute apart at the closest, and passes run
+     * closer together than the window is wide, so one lands while a matching minute's first
+     * occurrence is still due and before any later minute has come round. It reads an occurrence of
+     * that minute and files the job under it. An occurrence this read passes over falls in a minute
+     * a pass before it answered for.
      */
     readOccurrences(expression, kind, tz, databaseTime) {
         const window = new Date(databaseTime - OCCURRENCE_WINDOW_SECONDS * 1000);
@@ -684,9 +683,9 @@ class Timekeeper extends EventEmitter {
                 continue;
             }
             const id = JSON.stringify([name, key]);
-            // A cron occurrence in the due window names no slot, since the insert files it from its own
-            // clock. That slot is the one the pass is running in, which is later than every slot a
-            // catch-up occurrence can name, so the current one stands in for it.
+            // A cron occurrence in the due window written by an older instance names no slot, since that
+            // insert filed it from its own clock. That slot is the one the pass was running in, which is
+            // later than every slot a catch-up occurrence can name, so the current one stands in for it.
             const filed = slot ?? throttleSlot(new Date(this.databaseTime));
             const latest = fired.get(id);
             if (latest === undefined || latest.slot <= filed) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pg-boss",
-  "version": "12.33.6",
+  "version": "12.33.7",
   "description": "Queueing jobs in Postgres from Node.js like a boss",
   "type": "module",
   "main": "./dist/index.js",