@classytic/arc-notifications 0.6.2 → 0.8.0

package/dist/index.mjs

@@ -1,7 +1,9 @@
+import { createTtlMemo } from "@classytic/repo-core/cache";
 import { BaseChannel, NotificationService, createSimpleResolver } from "@classytic/notifications";
 import { defineResource } from "@classytic/arc";
 import { NotFoundError } from "@classytic/arc/utils";
 import { defineJob } from "@classytic/arc/integrations/jobs";
+import { scopedValue } from "@classytic/arc/context";
 import { defineModule } from "@classytic/arc/factory";
 //#region src/backfill.ts
 function createInAppBackfill(options) {
@@ -114,23 +116,26 @@ const IN_APP_CHANNEL = "in-app";
 * TTL window.
 */
 function createCachedTriggerOverrideStore(load, options = {}) {
-	const ttlMs = options.ttlMs ?? 3e4;
-	const cache = /* @__PURE__ */ new Map();
+	/**
+	* `createTtlMemo`, never a hand-rolled map: the map wrote its entry AFTER
+	* the await, so the N channel expansions a parallel host dispatches together
+	* all missed. Single flight is what makes the TTL mean anything here.
+	*/
+	const memo = createTtlMemo(load, {
+		ttlMs: options.ttlMs ?? 3e4,
+		keyOf: (organizationId) => organizationId ?? "__company__"
+	});
 	return {
-		async forOrganization(organizationId) {
-			const key = organizationId ?? "__company__";
-			const hit = cache.get(key);
-			if (hit && Date.now() - hit.at < ttlMs) return hit.rows;
-			const rows = await load(organizationId);
-			cache.set(key, {
-				at: Date.now(),
-				rows
-			});
-			return rows;
+		forOrganization(organizationId) {
+			return memo.get(organizationId);
 		},
-		/** Call after a write so an admin sees their change immediately. */
+		/**
+		* Call after a write so an admin sees their change immediately. The
+		* in-process clear completes before this returns; the promise it wraps
+		* only exists to satisfy the adapter contract.
+		*/
 		invalidate() {
-			cache.clear();
+			memo.invalidate();
 		}
 	};
 }
@@ -277,23 +282,16 @@ function createNotificationChannelCatalog(connectorChannels = []) {
 */
 function createDbFirstResolver(options) {
 	const { store, fallback, cacheTtlMs = 6e4, escape: escapeHtml = true, onError } = options;
-	const cache = /* @__PURE__ */ new Map();
-	const lookup = async (key) => {
-		if (cacheTtlMs > 0) {
-			const hit = cache.get(key);
-			if (hit && Date.now() - hit.at < cacheTtlMs) return hit.doc;
-		}
-		const doc = await store.getByKey(key);
-		if (cacheTtlMs > 0) cache.set(key, {
-			doc,
-			at: Date.now()
-		});
-		return doc;
-	};
+	/**
+	* Single-flight memo: one event's channel expansions resolve the same key in
+	* the same tick, and a `null` row (no draft) is an answer worth keeping. A
+	* store failure rejects every waiter and caches nothing.
+	*/
+	const lookup = createTtlMemo((key) => store.getByKey(key), { ttlMs: cacheTtlMs });
 	const resolver = (async (templateId, data) => {
 		let doc = null;
 		try {
-			doc = await lookup(templateId);
+			doc = await lookup.get(templateId);
 		} catch (err) {
 			onError?.(err, templateId);
 			if (!fallback) throw err;
@@ -308,8 +306,7 @@ function createDbFirstResolver(options) {
 		return fallback(templateId, data);
 	});
 	resolver.invalidate = (key) => {
-		if (key === void 0) cache.clear();
-		else cache.delete(key);
+		lookup.invalidate(key);
 	};
 	return resolver;
 }
@@ -853,6 +850,31 @@ function notificationsModule(config) {
 		}
 	});
 }
+const audienceSlot = Symbol("arc-notifications.resolvedAudience");
+/** Content key for an audience — key order must not fragment the memo. */
+function audienceKey(audience) {
+	return JSON.stringify(audience, (_k, v) => v !== null && typeof v === "object" && !Array.isArray(v) ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => a < b ? -1 : 1)) : v);
+}
+/**
+* Resolve an audience ONCE per dispatch, shared by every expansion that asks.
+*
+* The resolver is a database read in every real host (members by role, then
+* users for contact); N channel expansions of one trigger hand it the same
+* audience. Keyed on CONTENT, so two triggers asking the same question share
+* too. A rejected resolution is dropped so the next expansion retries.
+* Outside a work scope nothing is shared.
+*/
+function resolveAudience(resolver, audience, event) {
+	const memo = scopedValue(audienceSlot, () => /* @__PURE__ */ new Map());
+	if (!memo) return Promise.resolve(resolver(audience, event));
+	const key = audienceKey(audience);
+	const pending = memo.get(key);
+	if (pending) return pending;
+	const created = Promise.resolve(resolver(audience, event));
+	memo.set(key, created);
+	created.catch(() => memo.delete(key));
+	return created;
+}
 /** One event → N sends. Exported for direct unit testing. */
 async function dispatchTrigger(service, trigger, event, opts) {
 	let resolved;
@@ -860,7 +882,7 @@ async function dispatchTrigger(service, trigger, event, opts) {
 	else if (trigger.audience) {
 		const audience = await trigger.audience(event);
 		if (audience === null || audience === void 0) return;
-		resolved = opts?.recipientResolver ? await opts.recipientResolver(audience, event) : void 0;
+		resolved = opts?.recipientResolver ? await resolveAudience(opts.recipientResolver, audience, event) : void 0;
 	}
 	if (!resolved) return;
 	const recipients = Array.isArray(resolved) ? resolved : [resolved];
@@ -1154,6 +1176,33 @@ function templatesResource(options) {
 //#endregion
 //#region src/triggerAdapter.ts
 /**
+* Trigger registry → `notifyOn` config.
+*
+* The host writes a flat, readable registry of `NotificationTrigger`s (what
+* fires, who gets it, what it says). The module wants `NotifyTrigger`s
+* (channels, audience resolver, data resolver, in-app block). This is the
+* conversion, and it is identical in every host — only the registry DATA differs.
+*
+* Moved here from `@spinekit/core/notifications` (2026-08-14) so it returns the
+* REAL `NotifyTrigger` instead of a hand-maintained structural mirror.
+*
+* ## What is BAKED IN
+*   - customer-audience triggers get NO in-app channel. Buyers are not dashboard
+*     users; a feed row for them is a row nobody can ever read.
+*   - a trigger's `channels` list appends those channels unconditionally.
+*     Hub-backed channels no-op when no provider is connected, so naming a
+*     channel is always safe — the provider's presence IS the gate. Channel
+*     names are OPEN: this package never enumerates the product's connectors.
+*   - `extract` returning `null` yields a `null` audience, which the module
+*     treats as "skip". This is how a trigger filters a broad event.
+*   - a customer trigger whose `extract` returns no `recipient` also skips,
+*     rather than dispatching to nobody.
+*
+* ## What stays HOST
+*   - the registry itself (business copy, roles, which events matter)
+*   - any entity kinds beyond the defaults, via `entityIdVars`
+*/
+/**
 * `entityType` → the `extract` variable holding that entity's id.
 *
 * The in-app row wants an `entityId` for deep-linking and badge grouping, but
@@ -1351,14 +1400,34 @@ function toGatedNotifyTriggers(t, options, overrides) {
 		message: t.template.message,
 		...t.priority ? { priority: t.priority } : {}
 	};
+	/**
+	* The effective settings resolve ONCE per event per trigger, shared by every
+	* channel expansion below, memoised on the work scope arc enters per
+	* dispatch. The slot is per TRIGGER (a fresh symbol per call), so two
+	* triggers on one event never share a resolution even when they share a
+	* type. Outside a scope there is nothing to share — one read per expansion,
+	* slower, never wrong.
+	*/
+	const slot = Symbol("arc-notifications.effectiveSettings");
+	const effectiveFor = (organizationId) => {
+		const load = async () => resolveEffectiveSettings(type, organizationId, await overrides.store.forOrganization(organizationId), defaults);
+		const memo = scopedValue(slot, () => /* @__PURE__ */ new Map());
+		if (!memo) return load();
+		const key = organizationId ?? "__company__";
+		const pending = memo.get(key);
+		if (pending) return pending;
+		const created = load();
+		memo.set(key, created);
+		created.catch(() => memo.delete(key));
+		return created;
+	};
 	return candidateChannels(t, options.catalog).map((channel) => ({
 		...base,
 		channels: [channel],
 		audience: async (e) => {
 			const ex = t.extract(e.payload ?? {});
 			if (!ex) return null;
-			const rows = await overrides.store.forOrganization(ex.organizationId ?? null);
-			const eff = resolveEffectiveSettings(type, ex.organizationId ?? null, rows, defaults);
+			const eff = await effectiveFor(ex.organizationId ?? null);
 			/**
 			* Report a skip so it is COUNTABLE, then skip.
 			*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classytic/arc-notifications",
-  "version": "0.6.2",
+  "version": "0.8.0",
   "description": "Notifications module for @classytic/arc — domain events → multi-channel notifications via @classytic/notifications, with DB-draftable templates, repo-backed delivery log, and a templates resource",
   "type": "module",
   "exports": {
@@ -29,10 +29,10 @@
     "prepublishOnly": "node ../../scripts/prepublish-gate.mjs"
   },
   "peerDependencies": {
-    "@classytic/arc": ">=2.35.0",
+    "@classytic/arc": ">=2.40.0",
     "@classytic/notifications": ">=2.5.0",
-    "@classytic/primitives": ">=0.25.0",
-    "@classytic/repo-core": ">=0.25.0"
+    "@classytic/primitives": ">=0.27.0",
+    "@classytic/repo-core": ">=0.27.1"
   },
   "keywords": [
     "arc",