easy-ping 0.5.0 → 0.6.0

package/dist/index.cjs

@@ -20,6 +20,9 @@ function decodeBase64Url(value) {
   return bytes ? new TextDecoder().decode(bytes) : null;
 }
 
+// src/core/config.ts
+var INBOX_VERSION_HEADER = "x-easy-ping-inbox";
+
 // src/core/definition.ts
 function defineNotification(definition) {
   return definition;
@@ -51,6 +54,78 @@ var consoleLogger = {
   error: (message2, meta) => console.error(`[easy-ping] ${message2}`, meta ?? "")
 };
 
+// src/core/signals.ts
+var DELIVERIES_CHANNEL = "deliveries";
+var inboxChannel = (userId) => `inbox:${userId}`;
+function createMemorySignals() {
+  const handlers = /* @__PURE__ */ new Map();
+  return {
+    crossProcess: false,
+    publish(channel) {
+      const set = handlers.get(channel);
+      if (!set) return;
+      for (const handler of [...set]) {
+        queueMicrotask(() => {
+          try {
+            handler();
+          } catch {
+          }
+        });
+      }
+    },
+    subscribe(channel, handler) {
+      let set = handlers.get(channel);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        handlers.set(channel, set);
+      }
+      set.add(handler);
+      return () => {
+        set?.delete(handler);
+        if (set?.size === 0) handlers.delete(channel);
+      };
+    }
+  };
+}
+function createBridgedSignals(transport, onError) {
+  const local = createMemorySignals();
+  const remoteUnsubscribes = /* @__PURE__ */ new Map();
+  const counts = /* @__PURE__ */ new Map();
+  return {
+    crossProcess: true,
+    publish(channel) {
+      local.publish(channel);
+      Promise.resolve().then(() => transport.publish(channel)).catch(onError);
+    },
+    subscribe(channel, handler) {
+      const unsubscribeLocal = local.subscribe(channel, handler);
+      counts.set(channel, (counts.get(channel) ?? 0) + 1);
+      if (!remoteUnsubscribes.has(channel)) {
+        remoteUnsubscribes.set(
+          channel,
+          Promise.resolve().then(() => transport.subscribe(channel, () => local.publish(channel))).catch((error) => {
+            onError(error);
+            return () => {
+            };
+          })
+        );
+      }
+      return () => {
+        unsubscribeLocal();
+        const remaining = (counts.get(channel) ?? 1) - 1;
+        if (remaining > 0) {
+          counts.set(channel, remaining);
+          return;
+        }
+        counts.delete(channel);
+        const pending = remoteUnsubscribes.get(channel);
+        remoteUnsubscribes.delete(channel);
+        pending?.then((unsubscribe) => unsubscribe()).catch(onError);
+      };
+    }
+  };
+}
+
 // src/core/tokens.ts
 var encoder = new TextEncoder();
 var KEY_SALT = encoder.encode("easy-ping/tokens/v1");
@@ -304,6 +379,9 @@ function createHandler(deps) {
     const userId = await resolveUserId(request);
     if (userId === "error") return empty(500);
     if (userId === null) return empty(401);
+    if (request.method === "GET" && path === "/events") {
+      return deps.events ? events(request, userId, deps.events) : empty(404);
+    }
     if (request.method === "GET" && path === "/") {
       const limitParam = Number(url.searchParams.get("limit") ?? 20);
       const limit = Number.isFinite(limitParam) ? Math.min(Math.max(limitParam, 1), 100) : 20;
@@ -328,6 +406,7 @@ function createHandler(deps) {
       const before = typeof parsed.body.before === "string" ? new Date(parsed.body.before) : null;
       const cutoff = before && !Number.isNaN(before.getTime()) ? new Date(before.getTime() + 1) : /* @__PURE__ */ new Date();
       await deps.adapter.markSeen(userId, cutoff);
+      deps.signals.publish(inboxChannel(userId));
       return json({ ok: true });
     }
     if (request.method === "POST" && path === "/read") {
@@ -339,19 +418,99 @@ function createHandler(deps) {
         return json({ error: `at most ${MAX_READ_IDS} ids per request` }, 400);
       }
       const updated = await deps.adapter.markRead(userId, ids);
+      if (updated > 0) deps.signals.publish(inboxChannel(userId));
       return updated === 0 ? empty(404) : json({ updated });
     }
     if (request.method === "POST" && path === "/read-all") {
-      return json({ updated: await deps.adapter.markAllRead(userId) });
+      const updated = await deps.adapter.markAllRead(userId);
+      if (updated > 0) deps.signals.publish(inboxChannel(userId));
+      return json({ updated });
     }
     return empty(404);
   }
+  async function fingerprint(userId) {
+    const [page, unseen] = await Promise.all([
+      deps.adapter.listNotifications({ userId, limit: 1 }),
+      deps.adapter.countUnseen(userId)
+    ]);
+    const newest = page.notifications[0];
+    return `${newest?.id ?? ""}|${newest?.readAt ? 1 : 0}|${unseen}`;
+  }
+  function events(request, userId, settings) {
+    const encoder3 = new TextEncoder();
+    const timers = [];
+    let unsubscribe;
+    let closed = false;
+    let cleanup = () => {
+    };
+    const stream = new ReadableStream({
+      start(controller) {
+        const write = (text) => {
+          if (closed) return;
+          try {
+            controller.enqueue(encoder3.encode(text));
+          } catch {
+            cleanup();
+          }
+        };
+        cleanup = () => {
+          if (closed) return;
+          closed = true;
+          unsubscribe?.();
+          for (const timer of timers) clearInterval(timer);
+          try {
+            controller.close();
+          } catch {
+          }
+        };
+        const changed = () => write("event: changed\ndata: {}\n\n");
+        write("retry: 3000\n\nevent: ready\ndata: {}\n\n");
+        unsubscribe = deps.signals.subscribe(inboxChannel(userId), changed);
+        timers.push(setInterval(() => write(": keepalive\n\n"), settings.heartbeatMs));
+        if (!deps.signals.crossProcess && settings.probeIntervalMs > 0) {
+          let last;
+          fingerprint(userId).then((value) => {
+            last = value;
+          }).catch(() => {
+          });
+          timers.push(
+            setInterval(() => {
+              fingerprint(userId).then((value) => {
+                if (last !== void 0 && value !== last) changed();
+                last = value;
+              }).catch((error) => deps.logger.error("events probe failed", { error }));
+            }, settings.probeIntervalMs)
+          );
+        }
+        if (settings.maxDurationMs > 0) {
+          timers.push(
+            setTimeout(cleanup, settings.maxDurationMs)
+          );
+        }
+        request.signal?.addEventListener("abort", cleanup, { once: true });
+      },
+      cancel() {
+        cleanup();
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "content-type": "text/event-stream; charset=utf-8",
+        "cache-control": "no-cache, no-store",
+        connection: "keep-alive",
+        "x-accel-buffering": "no",
+        "x-content-type-options": "nosniff"
+      }
+    });
+  }
   async function handle(request) {
     try {
       return await route(request);
     } catch (error) {
       deps.logger.error("request failed", { url: request.url, error });
       return empty(500);
+    } finally {
+      deps.sweepOnRequest?.();
     }
   }
   return {
@@ -416,7 +575,7 @@ function backoffMs(attempt, strategy = "exponential") {
 var nextAttemptAt = (attempt, strategy, now = /* @__PURE__ */ new Date()) => new Date(now.getTime() + backoffMs(attempt, strategy));
 
 // src/core/runner.ts
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var DEFAULT_WORKER_IDLE_MS = 1e4;
 async function withTimeout(run, ms, label) {
   const controller = new AbortController();
   let timer;
@@ -605,22 +764,45 @@ function createRunner(deps) {
     }
   }
   function startWorker(options = {}) {
-    const intervalMs = options.intervalMs ?? 1e3;
+    const intervalMs = options.intervalMs ?? DEFAULT_WORKER_IDLE_MS;
     let stopped = false;
+    let wake;
+    let pending = false;
+    const unsubscribe = deps.signals?.subscribe(DELIVERIES_CHANNEL, () => {
+      pending = true;
+      wake?.();
+    });
+    const idle = (ms) => new Promise((resolve) => {
+      if (pending) {
+        pending = false;
+        resolve();
+        return;
+      }
+      const timer = setTimeout(done, ms);
+      function done() {
+        clearTimeout(timer);
+        wake = void 0;
+        pending = false;
+        resolve();
+      }
+      wake = done;
+    });
     const loop = (async () => {
       while (!stopped) {
         try {
           const result = await runOnce({ limit: options.batchSize ?? deps.batchSize });
-          if (result.claimed === 0) await sleep(intervalMs);
+          if (result.claimed === 0 && !stopped) await idle(intervalMs);
         } catch (error) {
           deps.logger.error("worker sweep failed", { error });
-          await sleep(intervalMs);
+          if (!stopped) await idle(intervalMs);
         }
       }
     })();
     return {
       stop: async () => {
         stopped = true;
+        unsubscribe?.();
+        wake?.();
         await loop;
       }
     };
@@ -958,6 +1140,7 @@ var CORE_ROUTES = [
   { method: "POST", path: "/seen", scope: { type: "user" }, owner: "core" },
   { method: "POST", path: "/read", scope: { type: "user" }, owner: "core" },
   { method: "POST", path: "/read-all", scope: { type: "user" }, owner: "core" },
+  { method: "GET", path: "/events", scope: { type: "user" }, owner: "core" },
   { method: "POST", path: "/cron", scope: { type: "machine" }, owner: "core" }
 ];
 var DEFAULTS = {
@@ -1082,6 +1265,20 @@ function easyPing(config) {
     }
   }
   for (const warning of warnings) logger.warn(warning);
+  const baseSignals = config.signals ?? createMemorySignals();
+  const inboxVersions = /* @__PURE__ */ new Map();
+  const signals = {
+    crossProcess: baseSignals.crossProcess,
+    publish(channel) {
+      if (channel.startsWith("inbox:")) {
+        if (inboxVersions.size > 5e4) inboxVersions.clear();
+        const userId = channel.slice("inbox:".length);
+        inboxVersions.set(userId, (inboxVersions.get(userId) ?? 0) + 1);
+      }
+      baseSignals.publish(channel);
+    },
+    subscribe: (channel, handler2) => baseSignals.subscribe(channel, handler2)
+  };
   const runner = createRunner({
     adapter: config.database,
     definitions: config.notifications,
@@ -1091,15 +1288,34 @@ function easyPing(config) {
     logger,
     leaseMs,
     batchSize: config.delivery?.batchSize ?? DEFAULTS.batchSize,
-    backoff: config.delivery?.backoff ?? "exponential"
+    backoff: config.delivery?.backoff ?? "exponential",
+    signals
   });
   const pluginRoutes = plugins.flatMap((plugin) => plugin.routes ?? []);
+  const events = config.events === false ? false : {
+    heartbeatMs: config.events?.heartbeatMs ?? 25e3,
+    probeIntervalMs: config.events?.probeIntervalMs ?? 3e4,
+    maxDurationMs: config.events?.maxDurationMs ?? 0
+  };
+  const sweepConfig = config.delivery?.sweepOnRequest;
+  let lastRequestSweep = 0;
+  const sweepOnRequest = sweepConfig && mode !== "inline" ? () => {
+    const settings = sweepConfig === true ? {} : sweepConfig;
+    const now = Date.now();
+    if (now - lastRequestSweep < (settings.everyMs ?? 5e3)) return;
+    lastRequestSweep = now;
+    const pass = runner.runOnce({ limit: settings.limit ?? 5 }).catch((error) => logger.error("request-driven sweep failed", { error }));
+    config.delivery?.waitUntil?.(pass);
+  } : void 0;
   const handler = createHandler({
     adapter: config.database,
     session: config.session,
     runner,
     logger,
     secret: config.secret,
+    signals,
+    events,
+    sweepOnRequest,
     basePath: config.basePath ?? DEFAULTS.basePath,
     pluginRoutes,
     trustedOrigins: config.trustedOrigins,
@@ -1131,6 +1347,10 @@ function easyPing(config) {
       }
     );
     if (result.notifications.length > 0) {
+      for (const notification of result.notifications) {
+        signals.publish(inboxChannel(notification.userId));
+      }
+      signals.publish(DELIVERIES_CHANNEL);
       const ids = result.notifications.flatMap(
         (notification) => notification.deliveries.map((delivery) => delivery.id)
       );
@@ -1163,8 +1383,13 @@ function easyPing(config) {
     send,
     handler,
     startWorker: (options) => runner.startWorker(options ?? {}),
+    inboxHeaders: (userId) => ({
+      [INBOX_VERSION_HEADER]: String(inboxVersions.get(userId) ?? 0)
+    }),
     listRoutes: () => [
-      ...CORE_ROUTES.filter((route) => route.path !== "/cron" || Boolean(config.cron?.secret)),
+      ...CORE_ROUTES.filter(
+        (route) => (route.path !== "/cron" || Boolean(config.cron?.secret)) && (route.path !== "/events" || events !== false)
+      ),
       ...plugins.flatMap(
         (plugin) => (plugin.routes ?? []).map((route) => ({
           method: route.method,
@@ -1200,12 +1425,16 @@ function defineClientPlugin(plugin) {
 
 exports.ConfigError = ConfigError;
 exports.DEFAULT_TOKEN_TTL_SECONDS = DEFAULT_TOKEN_TTL_SECONDS;
+exports.DELIVERIES_CHANNEL = DELIVERIES_CHANNEL;
 exports.EasyPingError = EasyPingError;
+exports.INBOX_VERSION_HEADER = INBOX_VERSION_HEADER;
 exports.MAX_BODY_BYTES = MAX_BODY_BYTES;
 exports.MAX_TOKEN_TTL_SECONDS = MAX_TOKEN_TTL_SECONDS;
 exports.MIN_SECRET_LENGTH = MIN_SECRET_LENGTH;
 exports.ValidationError = ValidationError;
 exports.consoleLogger = consoleLogger;
+exports.createBridgedSignals = createBridgedSignals;
+exports.createMemorySignals = createMemorySignals;
 exports.createRateLimiter = createRateLimiter;
 exports.createRunner = createRunner;
 exports.decodeBase64Url = decodeBase64Url;
@@ -1216,6 +1445,7 @@ exports.easyPing = easyPing;
 exports.encodeBase64Url = encodeBase64Url;
 exports.escapeHtml = escapeHtml;
 exports.expiresIn = expiresIn;
+exports.inboxChannel = inboxChannel;
 exports.readJsonBody = readJsonBody;
 exports.redactErrorMessage = redactErrorMessage;
 exports.signToken = signToken;