@zackbart/connecta 0.24.4 → 0.26.0

package/dist/routes/activity.js

@@ -1,172 +1,92 @@
+import { Duration, Effect } from "effect";
 import { InvalidActivityCursorError, } from "../activity.js";
-import { activityActorNamespace, authorize, privateJson, } from "./shared.js";
-const ACTIVITY_LABEL_CONCURRENCY = 8;
-const ACTIVITY_LABEL_PAGE_BUDGET_MS = 1_500;
-const ACTIVITY_LABEL_MAX_LENGTH = 160;
-function cleanActivityActorLabel(value) {
-    if (typeof value !== "string")
-        return undefined;
-    const compact = value.replace(/\s+/gu, " ").trim();
-    if (!compact)
-        return undefined;
-    return Array.from(compact).slice(0, ACTIVITY_LABEL_MAX_LENGTH).join("");
-}
-async function boundedActivityActorLabel(hook, id, budgetMs) {
-    let timer;
-    try {
-        return await Promise.race([
-            Promise.resolve(hook(id))
-                .then(cleanActivityActorLabel)
-                .catch(() => undefined),
-            new Promise((resolve) => {
-                timer = setTimeout(resolve, budgetMs);
-            }),
-        ]);
-    }
-    catch {
-        return undefined;
-    }
-    finally {
-        if (timer !== undefined)
-            clearTimeout(timer);
-    }
-}
+import { ACTOR_LABEL_BUDGET_MS, ACTOR_LABEL_CONCURRENCY, actorKey, cleanActorLabel, labelLookups, } from "./actor-labels.js";
+import { authorized, refuse, serveOperator } from "./operator.js";
+import { privateJson } from "./shared.js";
 /**
  * Add display-only actor labels to one authorized activity page. Resolution is
  * best-effort, bounded, and read-time only: stored events retain stable ids and
  * a profile-provider outage falls back to those ids without failing the page.
+ *
+ * At most eight lookups run at once, and the page waits for them for 1.5
+ * seconds in all: whatever has resolved by then is used, and the rest are
+ * abandoned, as they are when the reader leaves.
  */
-async function enrichActivityActorLabels(page, auth) {
-    const identities = new Map();
-    for (const event of page.events) {
-        if (!event.actor.id)
-            continue;
-        identities.set(JSON.stringify([
-            event.actor.kind,
-            event.actor.namespace,
-            event.actor.id,
-        ]), {
-            kind: event.actor.kind,
-            id: event.actor.id,
-            ...(event.actor.namespace
-                ? { namespace: event.actor.namespace }
-                : {}),
-        });
-    }
-    const queue = [...identities.entries()];
-    const labels = new Map();
-    let next = 0;
-    const deadline = Date.now() + ACTIVITY_LABEL_PAGE_BUDGET_MS;
-    const workers = Array.from({ length: Math.min(ACTIVITY_LABEL_CONCURRENCY, queue.length) }, async () => {
-        while (next < queue.length) {
-            const entry = queue[next++];
-            if (!entry)
-                return;
-            const [key, identity] = entry;
-            const sameKindProviders = auth
-                .map((provider, index) => ({ provider, index }))
-                .filter(({ provider }) => provider.kind === identity.kind);
-            const candidates = sameKindProviders.filter(({ provider }) => Boolean(provider.activityActorLabel));
-            const eligible = identity.namespace
-                ? candidates.filter(({ provider }) => activityActorNamespace(provider) === identity.namespace)
-                : (() => {
-                    const directoryKey = ({ provider, index, }) => {
-                        const namespace = activityActorNamespace(provider);
-                        return namespace === undefined
-                            ? `provider:${index}`
-                            : `namespace:${namespace}`;
-                    };
-                    // Every same-kind provider participates in the ambiguity check,
-                    // even if it cannot resolve labels. Otherwise a legacy ID owned
-                    // by a provider without a resolver could be disclosed to a
-                    // different provider that happens to have one.
-                    const directories = new Set(sameKindProviders.map(directoryKey));
-                    if (directories.size !== 1)
-                        return [];
-                    const [directory] = directories;
-                    return candidates.filter((candidate) => directoryKey(candidate) === directory);
-                })();
-            // One namespace is one directory. Use its first configured resolver so
-            // duplicate gate adapters over the same Clerk instance do not multiply
-            // the provider-level concurrency cap.
-            const provider = eligible[0]?.provider;
-            if (!provider)
-                continue;
-            const remaining = deadline - Date.now();
-            if (remaining <= 0)
-                return;
-            const label = await boundedActivityActorLabel(provider.activityActorLabel.bind(provider), identity.id, remaining);
+function enrichActivityActorLabels(page, auth) {
+    return Effect.suspend(() => {
+        const labels = new Map();
+        const resolve = ({ key, id, provider }) => Effect.tryPromise(() => Promise.resolve(provider.activityActorLabel(id))).pipe(Effect.map(cleanActorLabel), Effect.orElseSucceed(() => undefined), Effect.map((label) => {
             if (label)
                 labels.set(key, label);
+        }));
+        return Effect.forEach(labelLookups(page.events.map((event) => event.actor), auth), resolve, {
+            concurrency: ACTOR_LABEL_CONCURRENCY,
+            discard: true,
+        }).pipe(Effect.timeoutOption(Duration.millis(ACTOR_LABEL_BUDGET_MS)), Effect.map(() => ({
+            ...page,
+            events: page.events.map((event) => {
+                const resolved = event.actor.id
+                    ? labels.get(actorKey(event.actor))
+                    : undefined;
+                // Never trust or echo a `label` supplied by storage. The persisted event
+                // schema has no label; only this authenticated read path may add one.
+                const actor = {
+                    kind: event.actor.kind,
+                    ...(event.actor.id ? { id: event.actor.id } : {}),
+                    ...(event.actor.namespace
+                        ? { namespace: event.actor.namespace }
+                        : {}),
+                };
+                return {
+                    ...event,
+                    actor: resolved ? { ...actor, label: resolved } : actor,
+                };
+            }),
+        })));
+    });
+}
+function activityRead(context) {
+    const { url, opts } = context;
+    return Effect.gen(function* () {
+        const authz = yield* authorized(context, false);
+        if (!authz.operator)
+            return yield* refuse("operator access required", 403);
+        if (opts.activityReadGate &&
+            !(yield* Effect.promise(async () => opts.activityReadGate(authz.actor)))) {
+            return yield* refuse("forbidden", 403);
         }
+        const list = opts.activity?.list?.bind(opts.activity);
+        if (!list)
+            return yield* refuse("activity history is not configured", 404);
+        const cursor = url.searchParams.get("cursor") ?? undefined;
+        if (cursor && cursor.length > 500)
+            return yield* refuse("invalid cursor", 400);
+        const requestedLimit = Number(url.searchParams.get("limit") ?? "50");
+        const limit = Number.isFinite(requestedLimit)
+            ? Math.min(100, Math.max(1, Math.trunc(requestedLimit)))
+            : 50;
+        return yield* Effect.tryPromise({
+            try: () => list({ ...(cursor !== undefined ? { cursor } : {}), limit }),
+            catch: (error) => error,
+        }).pipe(Effect.flatMap((page) => enrichActivityActorLabels(page, opts.auth)), Effect.map((page) => privateJson(page)), 
+        // A page too malformed to label or serialize is the store's failure,
+        // like any other.
+        Effect.catchDefect((defect) => Effect.fail(defect)), Effect.catch((error) => {
+            if (error instanceof InvalidActivityCursorError) {
+                return refuse(error.message, 400);
+            }
+            opts.logger.error("[connecta] activity read failed", error);
+            return refuse("activity history is temporarily unavailable", 503);
+        }));
     });
-    await Promise.all(workers);
-    return {
-        ...page,
-        events: page.events.map((event) => {
-            const resolved = event.actor.id
-                ? labels.get(JSON.stringify([
-                    event.actor.kind,
-                    event.actor.namespace,
-                    event.actor.id,
-                ]))
-                : undefined;
-            // Never trust or echo a `label` supplied by storage. The persisted event
-            // schema has no label; only this authenticated read path may add one.
-            const actor = {
-                kind: event.actor.kind,
-                ...(event.actor.id ? { id: event.actor.id } : {}),
-                ...(event.actor.namespace
-                    ? { namespace: event.actor.namespace }
-                    : {}),
-            };
-            return {
-                ...event,
-                actor: resolved ? { ...actor, label: resolved } : actor,
-            };
-        }),
-    };
 }
 export async function routeActivity(context) {
-    const { path, request, url, baseUrl, opts, runtimeContext } = context;
+    const { path, request } = context;
     if (path !== "/ui/activity")
         return null;
     if (request.method !== "GET") {
         return privateJson({ error: "method not allowed" }, { status: 405 });
     }
-    const authz = await authorize(request, baseUrl, opts.auth, runtimeContext, opts.identity, false);
-    if (!authz.ok)
-        return authz.response;
-    if (!authz.operator) {
-        return privateJson({ error: "operator access required" }, { status: 403 });
-    }
-    if (opts.activityReadGate &&
-        !(await opts.activityReadGate(authz.actor))) {
-        return privateJson({ error: "forbidden" }, { status: 403 });
-    }
-    if (!opts.activity?.list) {
-        return privateJson({ error: "activity history is not configured" }, { status: 404 });
-    }
-    const cursor = url.searchParams.get("cursor") ?? undefined;
-    if (cursor && cursor.length > 500) {
-        return privateJson({ error: "invalid cursor" }, { status: 400 });
-    }
-    const requestedLimit = Number(url.searchParams.get("limit") ?? "50");
-    const limit = Number.isFinite(requestedLimit)
-        ? Math.min(100, Math.max(1, Math.trunc(requestedLimit)))
-        : 50;
-    try {
-        const page = await opts.activity.list({
-            ...(cursor !== undefined ? { cursor } : {}),
-            limit,
-        });
-        return privateJson(await enrichActivityActorLabels(page, opts.auth));
-    }
-    catch (error) {
-        if (error instanceof InvalidActivityCursorError) {
-            return privateJson({ error: error.message }, { status: 400 });
-        }
-        opts.logger.error("[connecta] activity read failed", error);
-        return privateJson({ error: "activity history is temporarily unavailable" }, { status: 503 });
-    }
+    // A read: a reader who leaves stops the label lookups still queued.
+    return serveOperator(activityRead(context), request.signal);
 }

package/dist/routes/actor-labels.js

@@ -0,0 +1,114 @@
+// Display labels for stored actors, shared by the activity page and the
+// artifact library. An actor is stored as a stable id; a label is resolved at
+// read time from the one auth provider that owns the actor's directory, and
+// only on an authorized read path. Nothing here is persisted, and a label a
+// store happens to carry is never trusted or echoed.
+import { activityActorNamespace } from "./shared.js";
+export const ACTOR_LABEL_CONCURRENCY = 8;
+export const ACTOR_LABEL_BUDGET_MS = 1_500;
+const ACTOR_LABEL_MAX_LENGTH = 160;
+export function cleanActorLabel(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const compact = value.replace(/\s+/gu, " ").trim();
+    if (!compact)
+        return undefined;
+    return Array.from(compact).slice(0, ACTOR_LABEL_MAX_LENGTH).join("");
+}
+export function actorKey(actor) {
+    return JSON.stringify([actor.kind, actor.namespace, actor.id]);
+}
+/**
+ * One lookup per distinct actor, each against the single provider that owns
+ * the actor's directory. An actor no provider can claim unambiguously gets no
+ * lookup at all.
+ */
+export function labelLookups(actors, auth) {
+    const identities = new Map();
+    for (const actor of actors) {
+        if (!actor.id)
+            continue;
+        identities.set(actorKey(actor), {
+            kind: actor.kind,
+            id: actor.id,
+            ...(actor.namespace ? { namespace: actor.namespace } : {}),
+        });
+    }
+    const lookups = [];
+    for (const [key, identity] of identities) {
+        const sameKindProviders = auth
+            .map((provider, index) => ({ provider, index }))
+            .filter(({ provider }) => provider.kind === identity.kind);
+        const candidates = sameKindProviders.filter(({ provider }) => Boolean(provider.activityActorLabel));
+        const eligible = identity.namespace
+            ? candidates.filter(({ provider }) => activityActorNamespace(provider) === identity.namespace)
+            : (() => {
+                const directoryKey = ({ provider, index, }) => {
+                    const namespace = activityActorNamespace(provider);
+                    return namespace === undefined
+                        ? `provider:${index}`
+                        : `namespace:${namespace}`;
+                };
+                // Every same-kind provider participates in the ambiguity check,
+                // even if it cannot resolve labels. Otherwise a legacy ID owned
+                // by a provider without a resolver could be disclosed to a
+                // different provider that happens to have one.
+                const directories = new Set(sameKindProviders.map(directoryKey));
+                if (directories.size !== 1)
+                    return [];
+                const [directory] = directories;
+                return candidates.filter((candidate) => directoryKey(candidate) === directory);
+            })();
+        // One namespace is one directory. Use its first configured resolver so
+        // duplicate gate adapters over the same Clerk instance do not multiply
+        // the provider-level concurrency cap.
+        const provider = eligible[0]?.provider;
+        if (provider)
+            lookups.push({ key, id: identity.id, provider });
+    }
+    return lookups;
+}
+/**
+ * Resolve labels for `actors`, best-effort: at most eight lookups at once,
+ * 1.5 seconds in all, and whatever has resolved by then is the answer. A
+ * provider outage yields no labels, never a failed read.
+ */
+export async function resolveActorLabels(actors, auth) {
+    const labels = new Map();
+    const queue = labelLookups(actors, auth);
+    let cursor = 0;
+    let expired = false;
+    const worker = async () => {
+        while (!expired && cursor < queue.length) {
+            const lookup = queue[cursor++];
+            if (!lookup)
+                return;
+            try {
+                const label = cleanActorLabel(await Promise.resolve(lookup.provider.activityActorLabel?.(lookup.id)));
+                if (label && !expired)
+                    labels.set(lookup.key, label);
+            }
+            catch {
+                // A failed lookup leaves the actor unlabeled.
+            }
+        }
+    };
+    let timer;
+    const budget = new Promise((resolve) => {
+        timer = setTimeout(() => {
+            expired = true;
+            resolve();
+        }, ACTOR_LABEL_BUDGET_MS);
+    });
+    try {
+        await Promise.race([
+            Promise.all(Array.from({ length: Math.min(ACTOR_LABEL_CONCURRENCY, queue.length) }, worker)),
+            budget,
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+    return new Map(labels);
+}