@teamscala/service-boot 0.23.516 → 0.23.518

package/src/register-page-server-client.test.ts

@@ -1,185 +0,0 @@
-// @system ui-service-boot
-// @status handwritten
-// @edit edit directly
-//
-// register-page-server-client.test.ts — the declaredModels lookup must never
-// quietly report "declares nothing".
-//
-// The regression this exists for (measured scala-sign 2026-09-24/25): the boot
-// looked up service_schema with `undefined as never`, so loadRegistryConfig's
-// `v.parse(undefined, raw)` threw a TypeError on EVERY service, the bare
-// `catch {}` swallowed it into `declaredModels = []`, and the
-// "declares > 0 models + no router → refuse the boot" check below never fired.
-// A service declaring 18 models logged "0 declared model(s)", registered a
-// router-less server client as healthy, and served 500 on every page while
-// /health answered 200.
-//
-// Three assertions, each the operator's demand ("the catch must tell 'no
-// service_schema row' apart from 'the read failed'. A read error must never
-// quietly become 'no models'. Test both"):
-//   1. a service that DECLARES models with no generated router → REFUSES the
-//      boot (proves the refusal actually fires now — it did not before);
-//   2. a service with NO service_schema row → passes through clean (legitimate
-//      daemon/portal shell owns no DB models);
-//   3. a service_schema READ that FAILS → REFUSES the boot naming the error
-//      (a read error is never treated as "declares nothing").
-
-import { afterEach, describe, expect, mock, test } from "bun:test";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-const originalCwd = process.cwd();
-const tempDirs: string[] = [];
-
-afterEach(async () => {
-	process.chdir(originalCwd);
-	for (const directory of tempDirs.splice(0)) {
-		await rm(directory, { recursive: true, force: true });
-	}
-});
-
-// The registry read is scenario-driven: ONE load-config mock serves all three
-// tests, and each test flips the mode before calling the function. The mock
-// function is re-invoked on every call (the target imports it dynamically
-// inside registerPageServerClient), so switching the mode takes effect.
-let registryMode:
-	| { kind: "row"; models: string[] }
-	| { kind: "missing" }
-	| { kind: "missing-thrown" }
-	| { kind: "read-failed"; message: string } = { kind: "missing" };
-
-// The class identity the catch's `instanceof` compares against. The target
-// imports RegistryConfigMissingError from @teamscala/db/registry/errors, so the
-// SAME mocked class must back both the throw path and the instanceof check.
-class MockRegistryConfigMissingError extends Error {
-	readonly type: string;
-	readonly slug: string;
-	constructor(type: string, slug: string) {
-		super(`[registry] Config entry "${slug}" of type "${type}" not found`);
-		this.name = "RegistryConfigMissingError";
-		this.type = type;
-		this.slug = slug;
-	}
-}
-
-mock.module("@teamscala/db/registry/load-config", () => ({
-	loadOptionalRegistryConfig: async () => {
-		if (registryMode.kind === "missing") return null;
-		if (registryMode.kind === "missing-thrown") {
-			throw new MockRegistryConfigMissingError("service_schema", "scala-sign");
-		}
-		if (registryMode.kind === "row") return { models: registryMode.models };
-		throw new Error(registryMode.message);
-	},
-	loadRegistryConfig: async () => ({ platformOrganisationId: "org-platform" }),
-}));
-
-mock.module("@teamscala/db/registry/errors", () => ({
-	RegistryConfigMissingError: MockRegistryConfigMissingError,
-}));
-
-mock.module("@teamscala/db-validation/registry-schemas/service-schema", () => ({
-	ServiceSchemaConfigSchema: {},
-}));
-
-mock.module("@teamscala/db-validation/registry-schemas/platform-identity", () => ({
-	PlatformIdentitySchema: {},
-}));
-
-mock.module("@teamscala/logger/app-loggers", () => ({
-	getAppLogger: () => ({
-		info: (..._args: unknown[]) => {},
-		warn: (..._args: unknown[]) => {},
-		error: (..._args: unknown[]) => {},
-	}),
-}));
-
-mock.module("@orpc/server", () => ({
-	createRouterClient: () => ({}),
-}));
-
-mock.module("@teamscala/db/prisma-registry", () => ({
-	getPrisma: () => ({}),
-}));
-
-// The page-server server-client is imported dynamically via a string-cast
-// specifier inside the function; mock the exact specifier so setServerClient
-// is a recording no-op and the real runtime never loads.
-const setServerClientCalls: number[] = [];
-mock.module("@teamscala/service-boot/page-server-orpc/server-client", () => ({
-	setServerClient: () => {
-		setServerClientCalls.push(1);
-	},
-}));
-
-const { registerPageServerClient } = await import(
-	"./register-page-server-client.ts"
-);
-
-/** Make an empty service dir with NO generated router anywhere, and reset the
- *  setServerClient recorder so each test's count is its own. */
-async function cwdWithoutRouter(): Promise<string> {
-	setServerClientCalls.length = 0;
-	const dir = await mkdtemp(join(tmpdir(), "register-psc-test-"));
-	tempDirs.push(dir);
-	process.chdir(dir);
-	return dir;
-}
-
-describe("registerPageServerClient — declaredModels lookup never lies", () => {
-	test("refuses the boot when the service DECLARES models but no router exists", async () => {
-		await cwdWithoutRouter();
-		registryMode = {
-			kind: "row",
-			// 18 models — the exact scala-sign row size whose absence from the
-			// boot log was the outage.
-			models: Array.from({ length: 18 }, (_unused, index) => `model_${index}`),
-		};
-
-		await expect(registerPageServerClient("scala-sign")).rejects.toThrow(
-			/service_schema declares 18 model\(s\).*no generated ORPC router is present/s,
-		);
-		expect(setServerClientCalls.length).toBe(0);
-	});
-
-	test("passes through clean when there is NO service_schema row", async () => {
-		await cwdWithoutRouter();
-		// loadOptionalRegistryConfig returns null — the legitimately-declares-
-		// nothing case (daemon/portal shell). With no models declared there is no
-		// router required, so the boot must NOT refuse.
-		registryMode = { kind: "missing" };
-
-		await expect(registerPageServerClient("some-daemon-shell")).resolves.toBeUndefined();
-		expect(setServerClientCalls.length).toBeGreaterThan(0);
-	});
-
-	test("refuses the boot when the service_schema READ fails, naming the error", async () => {
-		await cwdWithoutRouter();
-		// A read error (NOT a missing row) must fail the boot, never degrade to
-		// "declares nothing" — otherwise a data-backed service boots "0 models"
-		// and 500s on every page.
-		registryMode = { kind: "read-failed", message: "connection refused: db down" };
-
-		await expect(registerPageServerClient("scala-sign")).rejects.toThrow(
-			/service_schema read FAILED for "scala-sign"/,
-		);
-		await expect(registerPageServerClient("scala-sign")).rejects.toThrow(
-			/connection refused: db down/,
-		);
-		expect(setServerClientCalls.length).toBe(0);
-	});
-
-	test("treats a thrown RegistryConfigMissingError as declares-nothing, not failure", async () => {
-		await cwdWithoutRouter();
-		// The read path throws RegistryConfigMissingError (a genuinely-absent row,
-		// the same signal as a null return, just a different code path): the catch
-		// must classify it as "declares nothing" via the instanceof check and boot
-		// CLEAN — this is exactly the branch that must NOT fail the boot. Contrast
-		// the read-failed test above, where an unrelated error DOES fail the boot.
-		registryMode = { kind: "missing-thrown" };
-
-		await expect(registerPageServerClient("scala-sign")).resolves.toBeUndefined();
-		expect(setServerClientCalls.length).toBeGreaterThan(0);
-	});
-});

package/src/resolve-app-base-url.ts

@@ -1,35 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * The scala-projects app's own public hostname, read from its `service_install`
- * row rather than hardcoded — a service knows its own deploy config only
- * through the registry (registries-are-source-of-truth), never a literal in
- * source. Cached for the process lifetime: this changes only on a redeploy,
- * not per-request. Shared by every server-side path that builds a link back
- * into the app (approval emails, mention emails, digest emails).
- */
-
-import { ServiceInstallConfigSchema } from "@teamscala/db-validation/registry-schemas/service-install";
-import { loadRegistryConfig } from "@teamscala/db/registry/load-config";
-import { createCache } from "@teamscala/cache/create-cache";
-
-const appUrlCache = createCache<string>("service-boot:app-base-url", {
-	ttlMs: Number.POSITIVE_INFINITY,
-	maxSize: 1,
-});
-
-export async function resolveAppBaseUrl(): Promise<string> {
-	const hit = appUrlCache.get("default");
-	if (hit) return hit;
-	try {
-		const config = await loadRegistryConfig("service_install", "scala-projects", ServiceInstallConfigSchema);
-		const url = `https://${config.public_hostname}`;
-		appUrlCache.set("default", url);
-		return url;
-	} catch {
-		appUrlCache.set("default", "https://projects.scala.business");
-		return "https://projects.scala.business";
-	}
-}

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

@@ -1,429 +0,0 @@
-// @system codegen
-// @status generated
-// @edit change the suite in the owned-suites band, then re-run codegen. Hand-edits are overwritten.
-//
-// This suite's assertions are OWNED by the codegen band: the band module
-// carries them verbatim, this file is the emission, and hand edits here are
-// overwritten on the next run. The rationale each assertion carries moved
-// with it into the band.
-
-import { describe, expect, test } from "bun:test";
-import { resolveFromLoaderConfig } from "./resolve-from-loader-config";
-import { interpolateMeta } from "./interpolate-meta.ts";
-import {
-	getServerClient,
-	isServerClientRegistered,
-	setServerClient,
-} from "./page-server-orpc/server-client";
-
-describe("interpolateMeta (resolver_input ref contract)", () => {
-	test("a bare :sourceKey ref passes the whole resolved source object", () => {
-		const out = interpolateMeta(
-			{ response: ":response", assessment: ":assessment" },
-			{
-				response: { total_score: 48, category_scores: { "Be Seen": 46 } },
-				assessment: { title: "Launcha" },
-			},
-		);
-		// Whole objects flow through — the bug that blanked every report was these
-		// resolving to undefined (bare refs read from URL params, not resolved).
-		expect(out.response).toEqual({ total_score: 48, category_scores: { "Be Seen": 46 } });
-		expect(out.assessment).toEqual({ title: "Launcha" });
-	});
-
-	test("a bare ref with no resolved source key is left as the literal (interpolateMeta fallback)", () => {
-		// `:id` has no resolved source named "id" and params is empty here, so it
-		// does not resolve — interpolateMeta leaves the literal in place.
-		const out = interpolateMeta({ id: ":id" }, {});
-		expect(out.id).toBe(":id");
-	});
-
-	test("a dotted ref still reads a field off a resolved source", () => {
-		const out = interpolateMeta(
-			{ score: ":response.total_score" },
-			{ response: { total_score: 48 } },
-		);
-		expect(out.score).toBe(48);
-	});
-});
-
-describe("resource-loader model capability", () => {
-	test("an optional source still refuses a model absent from the generated client", async () => {		const original = isServerClientRegistered() ? getServerClient() : null;
-		setServerClient({} as never);
-		try {
-			await expect(
-				resolveFromLoaderConfig(
-					{
-						sources: [
-							{
-								key: "body",
-								source: "orpc",
-								model: "builda_pages",
-								optional: true,
-							},
-						],
-					},
-					{},
-				),
-			).rejects.toThrow(
-				'requires model "builda_pages", but the generated server client does not expose findFirst',
-			);
-		} finally {
-			setServerClient(original as never);
-		}
-	});
-
-	test("an optional source may resolve an absent row when the model capability exists", async () => {
-		const original = isServerClientRegistered() ? getServerClient() : null;
-		setServerClient({
-			builda_pages: { findFirst: async () => null },
-		} as never);
-		try {
-			await expect(
-				resolveFromLoaderConfig(
-					{
-						sources: [
-							{
-								key: "body",
-								source: "orpc",
-								model: "builda_pages",
-								optional: true,
-							},
-						],
-					},
-					{},
-				),
-			).resolves.toEqual({ body: null });
-		} finally {
-			setServerClient(original as never);
-		}
-	});
-});
-
-describe("resource_loader refs read both the snake and the camelCase spelling", () => {
-	// Loader rows author snake_case column names (page_id, organisation_id,
-	// prepared_for) while the v8 ORM hands back camelCase keys (pageId,
-	// organisationId, preparedFor). readField reads the spelled key first
-	// then its camelCase equivalent so neither side has to know the other.
-	// Measured through the ORPC branch: what the dependent source's findFirst
-	// RECEIVES as its where IS the resolution of `:proposal.page_id`.
-	const original = isServerClientRegistered() ? getServerClient() : null;
-
-	test("a snake_case ref resolves against a camelCase parent record", async () => {
-		const captured: { where: unknown } = { where: null };
-		const calls: string[] = [];
-		setServerClient({
-			builda_pages: {
-				findFirst: async (args: { where: Record<string, unknown> }) => {
-					calls.push(JSON.stringify(args.where));
-					// First call: the proposal source (id lookup) returns a
-					// camelCase row, exactly what the v8 chain hands back.
-					if (calls.length === 1) {
-						return {
-							id: "p1",
-							pageId: "page-uuid",
-							organisationId: "org-uuid",
-							preparedFor: "Klavdia Vainshtein",
-						};
-					}
-					// Second call: the dependent page source.
-					captured.where = args.where;
-					return { id: "page-uuid" };
-				},
-			},
-		} as never);
-		try {
-			await resolveFromLoaderConfig(
-				{
-					sources: [
-						{
-							key: "proposal",
-							source: "orpc",
-							model: "builda_pages",
-							where: { id: ":id" },
-							optional: false,
-						},
-						{
-							key: "page",
-							source: "orpc",
-							model: "builda_pages",
-							where: { id: ":proposal.page_id" },
-							optional: false,
-							depends_on: ["proposal"],
-						},
-					],
-				},
-				{ id: "p1" },
-			);
-		} finally {
-			setServerClient(original as never);
-		}
-		// The dependent source queried WITH the resolved page id, not an
-		// emptied filter matching an arbitrary row.
-		expect(captured.where).toEqual({ id: "page-uuid" });
-	});
-
-	test("identity-name fields resolve unchanged (id, path, slug)", async () => {
-		const captured: { where: unknown } = { where: null };
-		const calls: string[] = [];
-		setServerClient({
-			builda_pages: {
-				findFirst: async (args: { where: Record<string, unknown> }) => {
-					calls.push(JSON.stringify(args.where));
-					if (calls.length === 1) {
-						return { id: "p1", path: "/header", websiteId: "w-1" };
-					}
-					captured.where = args.where;
-					return { id: "p1" };
-				},
-			},
-		} as never);
-		try {
-			await resolveFromLoaderConfig(
-				{
-					sources: [
-						{
-							key: "page",
-							source: "orpc",
-							model: "builda_pages",
-							where: { id: ":id" },
-							optional: false,
-						},
-						{
-							key: "footer",
-							source: "orpc",
-							model: "builda_pages",
-							where: { path: ":page.path", website_id: ":page.website_id" },
-							optional: false,
-							depends_on: ["page"],
-						},
-					],
-				},
-				{ id: "p1" },
-			);
-		} finally {
-			setServerClient(original as never);
-		}
-		// path (identity) and website_id (snake → camel websiteId) both
-		// resolve through the same readField walk.
-		expect(captured.where).toEqual({ path: "/header", website_id: "w-1" });
-	});
-});
-
-describe("required sources refuse unresolvable where refs", () => {
-	// The 2026-09-03 proposal outage class: interpolateTemplate DROPS a key
-	// whose ref resolves undefined, so a required source queries with a
-	// partial (or empty) filter — which matches an ARBITRARY row or none,
-	// serving a silent empty page instead of failing. Null is a real value
-	// (an unset column) and must keep flowing through.
-	const original = isServerClientRegistered() ? getServerClient() : null;
-	const capturingClient = (captured: { where: unknown }) => ({
-		builda_pages: {
-			findFirst: async (args: { where: unknown }) => {
-				captured.where = args.where;
-				return { id: "row" };
-			},
-		},
-	} as never);
-
-	test("a required source with an undefined ref throws naming it", async () => {
-		setServerClient(capturingClient({ where: null }));
-		try {
-			await expect(
-				resolveFromLoaderConfig(
-					{
-						sources: [
-							{
-								key: "page",
-								source: "orpc",
-								model: "builda_pages",
-								where: { id: ":proposal.page_id" },
-								optional: false,
-							},
-						],
-					},
-					{ id: "p1" },
-				),
-			).rejects.toThrow(/required source "page".*:proposal\.page_id.*undefined/);
-		} finally {
-			setServerClient(original as never);
-		}
-	});
-
-	test("an optional source with the same undefined ref still resolves null", async () => {
-		setServerClient({
-			builda_pages: { findFirst: async () => null },
-		} as never);
-		try {
-			await expect(
-				resolveFromLoaderConfig(
-					{
-						sources: [
-							{
-								key: "page",
-								source: "orpc",
-								model: "builda_pages",
-								where: { id: ":proposal.page_id" },
-								optional: true,
-							},
-						],
-					},
-					{ id: "p1" },
-				),
-			).resolves.toEqual({ page: null });
-		} finally {
-			setServerClient(original as never);
-		}
-	});
-
-	test("a resolved null flows through as a null filter on a required source", async () => {
-		const captured = { where: null as unknown };
-		// The first source resolves a row whose partner_id IS null — null is a
-		// real value flowing through interpolation, not an unresolved ref.
-		setServerClient({
-			builda_pages: {
-				findFirst: async (args: { where: unknown }) => {
-					captured.where = args.where;
-					return (args.where as { id: string }).id === "p1"
-						? { id: "p1", partner_id: null }
-						: null;
-				},
-			},
-		} as never);
-		try {
-			await resolveFromLoaderConfig(
-				{
-					sources: [
-						{
-							key: "proposal",
-							source: "orpc",
-							model: "builda_pages",
-							where: { id: ":id" },
-							optional: false,
-						},
-						{
-							key: "partnerOrg",
-							source: "orpc",
-							model: "builda_pages",
-							where: { partner_id: ":proposal.partner_id" },
-							optional: false,
-							depends_on: ["proposal"],
-						},
-					],
-				},
-				{ id: "p1" },
-			);
-		} finally {
-			setServerClient(original as never);
-		}
-		// The partnerOrg source queried WITH { partner_id: null }, not refused.
-		expect(captured.where).toEqual({ partner_id: null });
-	});
-});
-
-describe("non-UUID URL refs resolve absent, never throw into the breaker", () => {
-	// A URL param that is not a uuid (a slug link, a scanner path) can never
-	// match a uuid column. The query failure IS the resource being missing
-	// for this URL — the same state as a deleted row — so it resolves null
-	// and the upstream primary-missing check renders the branded 404.
-	// Throwing here instead counted every dead shape as a CONSECUTIVE
-	// render-budget failure: 53 scanner hits in a row on scala-quiz prod
-	// (2026-09-11) sat the layer DEGRADED fail-closed and every real page
-	// 503'd for hours.
-	const original = isServerClientRegistered() ? getServerClient() : null;
-	const sqlError = (msg: string) => {
-		const e = new Error(msg);
-		e.name = "SqlQueryError";
-		return e;
-	};
-
-	test("a required source rejecting a non-uuid URL ref resolves null", async () => {
-		setServerClient({
-			builda_pages: {
-				findFirst: async () => {
-					throw sqlError('invalid input syntax for type uuid: "launcha-authority-index"');
-				},
-			},
-		} as never);
-		try {
-			await expect(
-				resolveFromLoaderConfig(
-					{
-						sources: [
-							{
-								key: "assessment",
-								source: "orpc",
-								model: "builda_pages",
-								where: { id: ":id" },
-								optional: false,
-							},
-						],
-					},
-					{ id: "launcha-authority-index" },
-				),
-			).resolves.toEqual({ assessment: null });
-		} finally {
-			setServerClient(original as never);
-		}
-	});
-
-	test("a SqlQueryError that is NOT a non-uuid ref still throws", async () => {
-		setServerClient({
-			builda_pages: {
-				findFirst: async () => {
-					throw sqlError('column "page_id" does not exist');
-				},
-			},
-		} as never);
-		try {
-			await expect(
-				resolveFromLoaderConfig(
-					{
-						sources: [
-							{
-								key: "page",
-								source: "orpc",
-								model: "builda_pages",
-								where: { id: ":id" },
-								optional: false,
-							},
-						],
-					},
-					{ id: "p1" },
-				),
-			).rejects.toThrow('column "page_id" does not exist');
-		} finally {
-			setServerClient(original as never);
-		}
-	});
-
-	test("a non-SqlQueryError rejection on a required source still throws", async () => {
-		setServerClient({
-			builda_pages: {
-				findFirst: async () => {
-					throw new Error("connection refused");
-				},
-			},
-		} as never);
-		try {
-			await expect(
-				resolveFromLoaderConfig(
-					{
-						sources: [
-							{
-								key: "page",
-								source: "orpc",
-								model: "builda_pages",
-								where: { id: ":id" },
-								optional: false,
-							},
-						],
-					},
-					{ id: "p1" },
-				),
-			).rejects.toThrow("connection refused");
-		} finally {
-			setServerClient(original as never);
-		}
-	});
-});