@teamscala/service-boot 0.23.413 → 0.23.414

package/src/register-registry-page-route/stamp-session-context.ts

@@ -0,0 +1,121 @@
+/**
+ * @system ui-service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Stamps the resolved-in-progress loader graph with the request's session
+ * identity: sessionVisitor, portalContext (user/orgId/pane widths from the
+ * portal cookie and the user's saved preferences). Anonymous when no session.
+ *
+ * Split out of register-registry-page-route.ts (924 lines) — the loadData
+ * closure segment moved byte-identical; only the closure variables became
+ * explicit parameters.
+ */
+
+import { getServerClient } from "../page-server-orpc/server-client.ts";
+
+export interface SessionIdentity {
+	sessionUserId: string | undefined;
+	sessionOrgId: string | undefined;
+}
+
+export async function stampSessionContext(
+	resolved: Record<string, unknown>,
+	request: Request,
+): Promise<SessionIdentity> {
+	const gateCookie = request.headers.get("cookie");
+	// Resolve the signed-in viewer from the unified auth session (local
+	// verify, works on Railway) and stamp it on the graph, so a gate can
+	// release on a standard OTP-login session (config.sessionAuthorize) —
+	// the unified path, no per-gate OTP code. Anonymous if no session.
+	let sessionUserId: string | undefined;
+	let sessionOrgId: string | undefined;
+	try {
+		const { getSession } = await import("@teamscala/auth/get-session.ts");
+		const sess = await getSession(request.headers);
+		if (sess?.user?.email) {
+			(resolved as { sessionVisitor?: { email: string; name?: string } }).sessionVisitor =
+				{
+					email: sess.user.email,
+					name: sess.user.name ?? undefined,
+				};
+			sessionUserId = sess.user.id;
+			sessionOrgId = sess.session?.activeOrganizationId ?? undefined;
+			// Stamp the per-request portal identity so block portal context
+			// (useBlockPortal().userId) is populated for authed users on
+			// org/hub pages — the SSR-side WRITER the connections-block reader
+			// (ClientBlockServicesProvider → __PAGE_DATA__.portalContext.user.id)
+			// depends on. Rides the same per-request path as sessionVisitor
+			// above (never the cached loader graph); merge preserves any
+			// portalContext fields set elsewhere (e.g. viewAsMembers). Without
+			// this, connections-block short-circuits at SignInPrompt.
+			const rc = resolved as {
+				portalContext?: {
+					user?: { id?: string } | null;
+					orgId?: string;
+				};
+			};
+			rc.portalContext = {
+				...(rc.portalContext ?? {}),
+				user: sessionUserId ? { id: sessionUserId } : null,
+				orgId: sessionOrgId,
+			};
+			// Read pane widths from the portal cookie (the client writes
+			// it immediately on resize via setPortalCookie; the cookie is
+			// sent with every HTTP request so the SSR reads it here).
+			// This renders the correct pane width from the first byte —
+			// no post-hydration shift, no client-side state read.
+			const paneWidthsMatch = gateCookie?.match(
+				/portal_pane_widths=([^;]+)/,
+			);
+			if (paneWidthsMatch) {
+				try {
+					const parsed = JSON.parse(
+						decodeURIComponent(paneWidthsMatch[1]),
+					);
+					if (parsed.left)
+						(rc.portalContext as Record<string, unknown>).paneLeftWidth =
+							parsed.left;
+					if (parsed.right)
+						(rc.portalContext as Record<string, unknown>).paneRightWidth =
+							parsed.right;
+				} catch {
+					// Malformed cookie — fall back to defaults.
+				}
+			}
+			if (sessionUserId) {
+				try {
+					const dbClient = getServerClient() as unknown as {
+						user: {
+							findUnique: (args: {
+								where: { id: string };
+								select: { preferences: boolean };
+							}) => Promise<{ preferences: unknown } | null>;
+						};
+					};
+					const userRow = await dbClient.user.findUnique({
+						where: { id: sessionUserId },
+						select: { preferences: true },
+					});
+					const portalPrefs = (
+						(userRow?.preferences as Record<string, unknown> | null)
+							?.portal as Record<string, unknown> | undefined
+					);
+					if (portalPrefs?.paneLeftWidth) {
+						(rc.portalContext as Record<string, unknown>).paneLeftWidth =
+							portalPrefs.paneLeftWidth;
+					}
+					if (portalPrefs?.paneRightWidth) {
+						(rc.portalContext as Record<string, unknown>).paneRightWidth =
+							portalPrefs.paneRightWidth;
+					}
+				} catch {
+					// Pane widths are non-critical — fall back to defaults.
+				}
+			}
+		}
+	} catch {
+		// No auth factory / no session → anonymous; gates fall back to token.
+	}
+	return { sessionUserId, sessionOrgId };
+}

package/src/register-registry-page-route/warn-uncovered-blocks.ts

@@ -0,0 +1,64 @@
+/**
+ * @system ui-service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Block-coverage guard (protective-layers-fail-explicitly) for registered
+ * page routes.
+ *
+ * Split out of register-registry-page-route.ts (924 lines) — byte-for-byte
+ * move; only the import paths adjusted.
+ */
+
+import { getAppLogger } from "@teamscala/logger/app-loggers";
+import type { RendererComponentEntry } from "../types.ts";
+
+/**
+ * A page that renders a block whose component is NOT registered — because
+ * its package is missing from service_install.config.block_packages —
+ * silently renders BLANK. That is the exact failure behind the 2026-06-04
+ * scala-sign regression (sign-in-block dropped from block_packages → the
+ * gate + signature fields vanished) which left only a benign boot WARN.
+ * This turns that silent blank into a loud, GlitchTip-visible ERROR naming
+ * the page + block, throttled to once per (service, block type) so a hot
+ * path can never spam it.
+ */
+const uncoveredBlocksLogged = new Set<string>();
+
+function collectBlockTypes(node: unknown, out: Set<string>): void {
+	if (Array.isArray(node)) {
+		for (const child of node) collectBlockTypes(child, out);
+		return;
+	}
+	if (node && typeof node === "object") {
+		const obj = node as Record<string, unknown>;
+		if (
+			typeof obj.type === "string" &&
+			obj.props &&
+			typeof obj.props === "object"
+		) {
+			out.add(obj.type);
+		}
+		for (const value of Object.values(obj)) collectBlockTypes(value, out);
+	}
+}
+
+export function warnUncoveredBlocks(
+	pageData: unknown,
+	components: Record<string, RendererComponentEntry>,
+	serviceSlug: string,
+	path: unknown,
+	log: ReturnType<typeof getAppLogger>,
+): void {
+	const used = new Set<string>();
+	collectBlockTypes(pageData, used);
+	for (const type of used) {
+		if (type in components) continue;
+		const key = `${serviceSlug}:${type}`;
+		if (uncoveredBlocksLogged.has(key)) continue;
+		uncoveredBlocksLogged.add(key);
+		log.error(
+			`[scala-install:${serviceSlug}] page "${String(path)}" renders block "${type}" but NO component is registered for it — its package is almost certainly missing from service_install.config.block_packages, so it renders BLANK. Add the owning @teamscala/* package to block_packages and restart. (block-coverage guard)`,
+		);
+	}
+}