@worker-protocol/cloudflare 0.8.0 → 0.8.1

package/README.md

@@ -202,6 +202,15 @@ Every id is derived from the transition, the resource and its `since`, and the i
 brings its birth with it. `heartbeat()` compares up to now and points the shared alarm at the next
 instant; a cron that calls it starts the chain and restarts it if an alarm is lost.
 
+**What a mixin does internally is a function of its module, never a method.** `private` is
+TypeScript's alone: at run time it is a method on the prototype, and a Worker whose class declares
+one of the same name replaces it silently. Only the methods each mixin's interface lists are on the
+object.
+
+`withSubscriptions` also answers `wantedHere(source, events)`: which events a live subscription it
+holds would receive, synchronously, so an object that keeps an outbox and the subscriptions leaves
+the rest out inside the transaction of the write that raised them.
+
 ## Also exported
 
 `durableOutcomes`, `durableSubscriptions` and `durableLogs` turn a stub into the store `mount()`

package/dist/lifecycle.js

@@ -51,24 +51,31 @@ export function lifecycleEventsBetween(given) {
         ]),
     ];
 }
+/**
+ * Owes each event not owed before, in the transaction the caller is in, and answers how many were
+ * new. The outbox holds an id back only while it waits; this remembers it after.
+ *
+ * **A function of the module and not a method of the mixin, and that is the rule for every mixin
+ * here.** `private` is TypeScript's alone: at run time it is a method on the prototype like any
+ * other, and `Mixed` does not carry it, so a Worker whose class declares a method of the same name
+ * replaces it without a word from the compiler or the runtime. Only what a mixin publishes as its
+ * interface is a method; what it does internally is reached by no subclass.
+ */
+function owe(given) {
+    const { storage, enqueue, now, events } = given;
+    const sql = migrate(storage, SCHEMA);
+    // `RETURNING` answers a row only for an id this inserted, and nothing for one already there.
+    const fresh = events.filter((event) => sql
+        .exec("INSERT INTO wp_lifecycle_owed (id, at) VALUES (?, ?) ON CONFLICT DO NOTHING RETURNING id", event.id, now)
+        .toArray().length > 0);
+    enqueue(now, fresh);
+    return fresh.length;
+}
 export function withLifecycle(Base, options = {}) {
     const catchUpMs = options.catchUpMs ?? 120 * MINUTE;
     const mostPerRunMs = options.mostPerRunMs ?? 60 * MINUTE;
     const keepAnnouncedMs = options.keepAnnouncedMs ?? 2 * 24 * 60 * MINUTE;
     class WithLifecycle extends Base {
-        /**
-         * Owes each event not owed before, in the transaction the calling method is in, and answers how
-         * many were new. The outbox holds an id back only while it waits; this remembers it after.
-         */
-        owe(now, events) {
-            const sql = migrate(this.ctx.storage, SCHEMA);
-            // `RETURNING` answers a row only for an id this inserted, and nothing for one already there.
-            const fresh = events.filter((event) => sql
-                .exec("INSERT INTO wp_lifecycle_owed (id, at) VALUES (?, ?) ON CONFLICT DO NOTHING RETURNING id", event.id, now)
-                .toArray().length > 0);
-            this.enqueue(now, fresh);
-            return fresh.length;
-        }
         /**
          * Performs `write` and owes what it changed: the Tasks and Alerts at `now` before it and after
          * it, compared in the same transaction as the write. `write` is synchronous, because the
@@ -77,7 +84,12 @@ export function withLifecycle(Base, options = {}) {
         changing(now, write) {
             const before = this.snapshot(now);
             const done = write();
-            this.owe(now, lifecycleEventsBetween({ previous: before, current: this.snapshot(now), at: now }));
+            owe({
+                storage: this.ctx.storage,
+                enqueue: (at, events) => this.enqueue(at, events),
+                now,
+                events: lifecycleEventsBetween({ previous: before, current: this.snapshot(now), at: now }),
+            });
             return done;
         }
         /**
@@ -110,7 +122,12 @@ export function withLifecycle(Base, options = {}) {
                     at = next;
                 }
             }
-            const fresh = this.owe(now, owed);
+            const fresh = owe({
+                storage: this.ctx.storage,
+                enqueue: (at, events) => this.enqueue(at, events),
+                now,
+                events: owed,
+            });
             sql.exec("INSERT OR REPLACE INTO wp_lifecycle_mark (one, at) VALUES (1, ?)", Math.max(to, from));
             sql.exec("DELETE FROM wp_lifecycle_owed WHERE at < ?", now - keepAnnouncedMs);
             await this.flush();

package/dist/subscriptions.d.ts

@@ -1,4 +1,4 @@
-import type { SubscriptionStore } from "@worker-protocol/hono";
+import { type Publishable, type SubscriptionStore } from "@worker-protocol/hono";
 import { type DurableObjectClass, type Mixed, type Rpc } from "./durable.ts";
 /** What `withSubscriptions` adds to a Durable Object. Every subscription crosses as JSON. */
 export interface SubscriptionMethods {
@@ -16,6 +16,7 @@ export interface SubscriptionMethods {
         clear: string[];
     }): void;
     removeSubscription(id: string): void;
+    wantedHere(source: string, events: Publishable[]): boolean[];
 }
 export declare function withSubscriptions<B extends DurableObjectClass>(Base: B): Mixed<B, SubscriptionMethods>;
 /** What `durableSubscriptions` needs of a stub: the methods `withSubscriptions` adds, over RPC. */

package/dist/subscriptions.js

@@ -1,3 +1,4 @@
+import { wantedBy, } from "@worker-protocol/hono";
 import { first } from "./durable.js";
 import { migrate } from "./schema.js";
 /**
@@ -103,6 +104,19 @@ export function withSubscriptions(Base) {
             const sql = migrate(this.ctx.storage, SCHEMA);
             sql.exec("DELETE FROM wp_subscription WHERE id = ?", id);
         }
+        /**
+         * Which of these events a live subscription held here would receive (SUB-13), answered
+         * synchronously — so a Worker can leave the rest out of its outbox inside the very transaction
+         * of the write that raised them, as `changing()` needs. `source` is the Worker's id, which every
+         * event carries (EVT-1); the envelope is the hub's own, so the filters read the same attributes.
+         */
+        wantedHere(source, events) {
+            return wantedBy({
+                source,
+                subscribed: (type) => this.subscriptionsFor(type).map(parse),
+                events,
+            });
+        }
     }
     return WithSubscriptions;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@worker-protocol/cloudflare",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "workerProtocolEdition": "0.6",
   "description": "The protocol's stores in Durable Objects, and the Queues between an outbox and a sink: mixins for ENDP-16, SUB-7, LOG-2 and an outbox, for Workers on Cloudflare",
   "keywords": [
@@ -39,7 +39,7 @@
     "NOTICE"
   ],
   "dependencies": {
-    "@worker-protocol/hono": "0.8.0"
+    "@worker-protocol/hono": "0.8.1"
   },
   "peerDependencies": {
     "hono": "^4.13.7",