@teamscala/service-boot 0.23.516 → 0.23.518

package/src/resolve-from-loader-config.ts

@@ -1,316 +0,0 @@
-/**
- * @system ui-service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Walks a resource_loader.sources[] graph and resolves each source in
- * dependency order. Returns an assembled data object keyed by source key.
- *
- * Source types: "orpc", "prisma", "resolver_fn".
- * Each source may declare depends_on for ordering.
- * Params are interpolated from URL params and prior resolved data.
- */
-
-import { getAppLogger } from "@teamscala/logger/app-loggers";
-import { loadRegistryConfig } from "@teamscala/db/registry/load-config";
-import type { ResolverFnKey } from "@teamscala/db/registry/generated/resolver-fn";
-import { ResolverFnConfigSchema } from "@teamscala/db-validation/registry-schemas/resolver-fn";
-import { getServerClient } from "./page-server-orpc/server-client";
-import { interpolateTemplate, resolveParamRef } from "./interpolate-meta";
-import {
-	MissingLoaderModelCapabilityError,
-	isUrlRefNotUuidError,
-} from "./loader-errors";
-
-interface SourceConfig {
-	key: string;
-	source: "orpc" | "prisma" | "resolver_fn";
-	model?: string;
-	where?: Record<string, unknown>;
-	select?: string[];
-	depends_on?: string[];
-	optional?: boolean;
-	resolver_fn?: string;
-	resolver_input?: Record<string, unknown>;
-	registry_filter?: Record<string, unknown>;
-	transforms?: string[];
-}
-
-interface LoaderConfig {
-	sources: SourceConfig[];
-	merge_strategy?: Record<string, unknown>;
-}
-
-function toSelectMap(
-	fields: string[] | undefined,
-): Record<string, boolean> | undefined {
-	if (!fields || fields.length === 0) return undefined;
-	const map: Record<string, boolean> = {};
-	for (const f of fields) map[f] = true;
-	return map;
-}
-
-/**
- * resolver_fn executor — registry-driven dispatch (business-logic-is-rows-plus-executors).
- * Reads the resolver_fn row (module+export) + dynamic-imports + calls it. Replaces the
- * hardcoded if(resolver_fn==='X') chain — adding a resolver is now a registry_edit row.
- */
-async function resolveByResolverFn(
-	slug: ResolverFnKey,
-	input: Record<string, unknown>,
-	params: Record<string, unknown>,
-): Promise<unknown> {
-	if (!slug) throw new Error("[resource_loader] resolver_fn source missing resolver_fn slug");
-	const row = await loadRegistryConfig("resolver_fn", slug, ResolverFnConfigSchema);
-	if (!row) {
-		throw new Error(
-			`[resource_loader] resolver_fn "${slug}" has no resolver_fn registry row — create one (module+export) or fix the resource_loader row`,
-		);
-	}
-	const mod = await import(row.module);
-	const fn = (mod as Record<string, unknown>)[row.export] as (args: {
-		input: Record<string, unknown>;
-		client: unknown;
-		params: Record<string, unknown>;
-	}) => Promise<unknown> | unknown;
-	if (typeof fn !== "function") {
-		throw new Error(
-			`[resource_loader] resolver_fn "${slug}": export "${row.export}" not a function in ${row.module}`,
-		);
-	}
-	return fn({ input, client: await getServerClient(), params });
-}
-
-/**
- * Exact `:ref` strings inside a raw where/resolver_input whose value resolves
- * to undefined — the keys interpolateTemplate DROPS. A dropped where key on a
- * required source would query with a partial (or empty) filter, which matches
- * an ARBITRARY row — worse than an error, so required sources refuse here
- * instead (`a-component-may-not-report-a-state-it-has-not-verified`). Null is
- * a real value (an unset column filtered as null) and never counts as broken.
- */
-function unresolvedTemplateRefs(
-	template: unknown,
-	params: Record<string, unknown>,
-	resolved: Record<string, unknown>,
-): string[] {
-	const broken: string[] = [];
-	const walk = (node: unknown): void => {
-		if (typeof node === "string") {
-			const exact = node.match(/^:([a-zA-Z0-9_.]+)$/);
-			if (exact && resolveParamRef(exact[1], params, resolved) === undefined) {
-				broken.push(exact[1]);
-			}
-			return;
-		}
-		if (Array.isArray(node)) {
-			for (const v of node) walk(v);
-			return;
-		}
-		if (node != null && typeof node === "object") {
-			for (const v of Object.values(node)) walk(v);
-		}
-	};
-	walk(template);
-	return broken;
-}
-
-async function resolveSource(
-	source: SourceConfig,
-	params: Record<string, unknown>,
-	resolved: Record<string, unknown>,
-): Promise<unknown> {
-	const client = await getServerClient();
-
-	switch (source.source) {
-		case "orpc":
-		case "prisma": {
-			if (!source.model) return null;
-			// OPTIONAL MEANS THE SOURCE MAY BE ABSENT. It has never meant the
-			// source may be A STRANGER'S ROW, and that is what an unfiltered
-			// query returns. This check previously guarded only REQUIRED
-			// sources, so every optional one whose ref failed to resolve issued
-			// `where: {}` and findFirst handed back an arbitrary first row.
-			//
-			// Measured 2026-09-03 on a live client proposal: page, website,
-			// contact, partnerOrg and clientOrg ALL queried with an empty where
-			// and loaded unrelated records, which then rendered as the page. The
-			// only correct source was `proposal`, whose ref is the URL param
-			// rather than a sibling. Nothing errored and the page answered 200.
-			//
-			// A dropped filter is now refused for every source that declared
-			// one. Required sources still throw; an optional source resolves to
-			// null — absent, which is exactly what optional promises.
-			if (source.where) {
-				const broken = unresolvedTemplateRefs(source.where, params, resolved);
-				if (broken.length > 0) {
-					const refs = broken.map((ref) => `:${ref}`).join(", ");
-					if (source.optional) {
-						getAppLogger().warn(
-							`[resource_loader] optional source "${source.key}": where ref(s) ${refs} resolved to undefined — treating the source as ABSENT rather than querying without them (an unfiltered read returns an arbitrary row)`,
-						);
-						return null;
-					}
-					throw new Error(
-						`[resource_loader] required source "${source.key}": where ref(s) ${refs} resolved to undefined — refusing to query without them (a dropped filter silently matches an arbitrary row)`,
-					);
-				}
-			}
-			const where = source.where
-				? (interpolateTemplate(source.where, params, resolved) as Record<
-						string,
-						unknown
-					>)
-				: ({} as Record<string, unknown>);
-			const model = client[source.model as keyof typeof client] as
-				| {
-						findFirst?: (args: {
-							where: unknown;
-							select: unknown;
-						}) => Promise<unknown>;
-				  }
-				| undefined;
-			if (!model?.findFirst) {
-				throw new MissingLoaderModelCapabilityError(source.model, source.key);
-			}
-			return model.findFirst({
-				where,
-				select: toSelectMap(source.select),
-			});
-		}
-		case "resolver_fn": {
-			const input = source.resolver_input
-				? (interpolateTemplate(
-						source.resolver_input,
-						params,
-						resolved,
-					) as Record<string, unknown>)
-				: {};
-
-			return resolveByResolverFn(
-				source.resolver_fn as ResolverFnKey,
-				input,
-				params,
-			);
-		}
-		default:
-			throw new Error(
-				`[resource_loader] Unknown source type "${source.source}" on source "${source.key}".`,
-			);
-	}
-}
-
-/**
- * Dependencies a source has on sibling sources, beyond its declared
- * `depends_on`: any `:key.field` template ref whose head names another source
- * resolves from `resolved` (see resolveParamRef), so it is a real ordering
- * edge even when the row forgot to declare it. Inferring these keeps the
- * parallel waves safe against under-declared rows — under the old serial
- * loop, row order silently masked missing declarations.
- */
-function sourceDeps(source: SourceConfig, sourceKeys: Set<string>): string[] {
-	const deps = new Set<string>(source.depends_on ?? []);
-	const scan = (template: unknown): void => {
-		if (typeof template === "string") {
-			for (const m of template.matchAll(
-				/:([a-zA-Z0-9_]+)\.[a-zA-Z0-9_.]+/g,
-			)) {
-				const head = m[1];
-				if (head && sourceKeys.has(head)) deps.add(head);
-			}
-		} else if (Array.isArray(template)) {
-			for (const v of template) scan(v);
-		} else if (template != null && typeof template === "object") {
-			for (const v of Object.values(template)) scan(v);
-		}
-	};
-	scan(source.where);
-	scan(source.resolver_input);
-	scan(source.registry_filter);
-	deps.delete(source.key);
-	return [...deps];
-}
-
-export async function resolveFromLoaderConfig(
-	config: LoaderConfig,
-	params: Record<string, unknown>,
-): Promise<Record<string, unknown>> {
-	const sources = config.sources ?? [];
-	const resolved: Record<string, unknown> = {};
-	const resolvedKeys = new Set<string>();
-
-	// Wave-parallel resolution per `loading-shape` (unrelated roots resolve
-	// concurrently): each wave gathers every source whose deps are satisfied
-	// and resolves them via Promise.allSettled — wall-clock per wave is the
-	// slowest source, not the sum. The previous strictly-serial loop cost
-	// N × DB-round-trip per page (~2.3s for a 5-source loader from the dev
-	// host); waves cut it to the dependency depth (typically 2).
-	const sourceKeys = new Set(sources.map((s) => s.key));
-	const depsByKey = new Map(
-		sources.map((s) => [s.key, sourceDeps(s, sourceKeys)]),
-	);
-
-	const maxIterations = sources.length + 1;
-	for (let iteration = 0; iteration < maxIterations; iteration++) {
-		const wave = sources.filter(
-			(s) =>
-				!resolvedKeys.has(s.key) &&
-				(depsByKey.get(s.key) ?? []).every((d) => resolvedKeys.has(d)),
-		);
-		if (wave.length === 0) {
-			if (resolvedKeys.size === sources.length) break;
-			const unresolved = sources
-				.filter((s) => !resolvedKeys.has(s.key))
-				.map((s) => s.key);
-			throw new Error(
-				`Circular or unresolvable dependency in resource_loader: ${unresolved.join(", ")}`,
-			);
-		}
-
-		const results = await Promise.allSettled(
-			wave.map((source) => resolveSource(source, params, resolved)),
-		);
-		for (let i = 0; i < wave.length; i++) {
-			const source = wave[i];
-			const result = results[i];
-			if (!source || !result) continue;
-			if (result.status === "fulfilled") {
-				resolved[source.key] = result.value;
-			} else if (isUrlRefNotUuidError(result.reason)) {
-				// A URL ref that cannot be a uuid names no resource: resolve the
-				// source ABSENT (null) and let the existing semantics decide —
-				// the primary-missing check upstream turns it into the branded
-				// 404 (PrimaryResourceMissingError, which the render-budget
-				// breaker already excludes), an optional source treats it like
-				// any absent row. Throwing here instead is what let dead links
-				// poison the breaker into a site-wide 503 (see the predicate).
-				getAppLogger().warn(
-					`[resource_loader] source "${source.key}" got a non-UUID URL ref — treating as MISSING for this request: ${
-						result.reason instanceof Error ? result.reason.message : String(result.reason)
-					}`,
-				);
-				resolved[source.key] = null;
-			} else if (
-				source.optional &&
-				!(result.reason instanceof MissingLoaderModelCapabilityError)
-			) {
-				// Optional means MAY BE ABSENT, never FAIL IN SILENCE: the source
-				// still resolves to null, but the reason becomes evidence.
-				getAppLogger().warn(
-					`[resource_loader] optional source "${source.key}" FAILED and is absent from this render: ${
-						result.reason instanceof Error
-							? `${result.reason.message}\n${result.reason.stack ?? ""}`
-							: String(result.reason)
-					}`,
-				);
-				resolved[source.key] = null;
-			} else {
-				throw result.reason;
-			}
-			resolvedKeys.add(source.key);
-		}
-		if (resolvedKeys.size === sources.length) break;
-	}
-
-	return resolved;
-}

package/src/resolve-service-context.ts

@@ -1,88 +0,0 @@
-/**
- * @system server-boot
- * @status handwritten
- * @edit edit directly
- *
- * Resolves the minimum service context the bin needs to choose its launch
- * path: connect DB, load registry, read service_install row, return kind +
- * port. Caller is responsible for disconnecting.
- */
-
-import { createDbClient } from "@teamscala/db/create-db-client";
-import type { PrismaClient } from "@teamscala/db/client";
-import { loadServicePrismaClient } from "@teamscala/db/load-service-prisma-client";
-import { registerPrismaClient } from "@teamscala/db/prisma-registry";
-import { loadRegistryEntries } from "@teamscala/db/registry/loader/load-entries";
-import type { ServiceInstallConfig } from "./load-service-install-row";
-import { loadServiceInstallRow } from "./load-service-install-row";
-
-export interface ServiceContext {
-	kind: "ui" | "backend" | "runtime";
-	port: number;
-	config: ServiceInstallConfig;
-	disconnect: () => Promise<void>;
-}
-
-export async function resolveServiceContext(
-	serviceSlug: string,
-	databaseUrl: string,
-): Promise<ServiceContext> {
-	// THE V8 CLIENT REGISTERS FIRST — before any registry read. getPrisma()
-	// serves the v8 model-indexed adapter (a81b9f0a), so an early registry
-	// read (getCookieDomain in buildMinimalApp, loadRegistryEntries) that ran
-	// against a v7-only registration found no `.orm` surface: 43695 threw
-	// "model not in the v8 client" (fleet-wide boot crash) and 43696+ degraded
-	// to EMPTY rows ("Config entry cookie-domain not found" on a row that has
-	// existed since July). Registering the real v8 client HERE — the earliest
-	// boot step — makes every later read resolve against the client the
-	// adapter expects. Measured 2026-09-03: this ordering gap took down every
-	// UI service for the second half of the Prisma 8 migration night.
-	const { createDbClientV8 } = await import("@teamscala/db/create-db-client-v8");
-	const db8 = await createDbClientV8({
-		connectionString: databaseUrl,
-		serviceName: serviceSlug,
-	});
-	const { registerDb8 } = await import("@teamscala/db/db8-registry");
-	registerDb8(db8 as never);
-	registerPrismaClient(db8 as never);
-
-	const PrismaClientConstructor = await loadServicePrismaClient(serviceSlug);
-	const dbClient = await createDbClient({
-		connectionString: databaseUrl,
-		serviceName: serviceSlug,
-		PrismaClientConstructor: PrismaClientConstructor as never,
-	});
-	// The v7 client stays ONLY as the explicit per-call client (loadRegistry-
-	// Entries below, callers' disconnect) — it must NOT re-register, or the
-	// v7 registration overwrites the v8 one and the reads break again.
-	await loadRegistryEntries(dbClient.prisma as never);
-
-	const rowResult = await loadServiceInstallRow(serviceSlug);
-	if (!rowResult.success) {
-		throw new Error(`[scala-install:${serviceSlug}] ${rowResult.message}`);
-	}
-	const cfg = rowResult.config;
-	const port = Number(cfg.port);
-	if (!Number.isFinite(port) || port <= 0) {
-		throw new Error(
-			`[scala-install:${serviceSlug}] invalid port "${cfg.port}" in service_install row`,
-		);
-	}
-	// Export the resolved port to process.env so loopback code reads the REAL
-	// port without a separate PORT injection. The central-tool-forwarder (the
-	// chat tool dispatch) falls back to http://localhost:${PORT} for the
-	// co-located /mcp; without this export every chat tool call fails with
-	// "cannot resolve the /mcp base URL" (the highlight-ring end-to-end blocker,
-	// 2026-07-02). Railway's $PORT (when present) is respected — only set when
-	// unset so prod's Railway-assigned port wins.
-	if (!process.env.PORT) process.env.PORT = String(port);
-
-	return {
-		kind: cfg.kind,
-		port,
-		config: cfg,
-		disconnect: async () => {
-			await dbClient.disconnect?.();
-		},
-	};
-}