@teamscala/service-boot 0.23.456 → 0.23.458

package/package.json

@@ -6,7 +6,7 @@
   },
   "name": "@teamscala/service-boot",
   "type": "module",
-  "version": "0.23.456",
+  "version": "0.23.458",
   "sideEffects": false,
   "imports": {
     "#service-boot/*": "./src/*",

package/src/build-client-assets/styles-build.ts

@@ -43,29 +43,68 @@ async function resolveStylesheetRaw(
 		}
 		return { path: p, base: dirname(p), content: await Bun.file(p).text() };
 	}
-	// Bare specifier: find node_modules/<id>/package.json by walking upward
-	// from the importing file's dir then cwd, and read the DECLARED STYLE
-	// entry (exports["."].style / style). Bun.resolve is not used here: it
-	// hands back whatever the package's main is — for a normal JS package
-	// that is a .js entry, not the declared stylesheet. A package with no
-	// style entry is not a stylesheet import: that is a build-breaking
-	// error naming the specifier, never an invented path whose ENOENT
-	// surfaces as a misleading downstream CSS error.
+	// A BARE SPECIFIER IS A PACKAGE NAME PLUS AN OPTIONAL SUBPATH, and the two
+	// must be separated before anything is looked up. `@teamscala/ui-foundation`
+	// is a package; `@teamscala/ui-foundation/theme/styles.css` is that same
+	// package plus an explicit file inside it. Treating the whole string as a
+	// package name looks for node_modules/@teamscala/ui-foundation/theme/
+	// styles.css/package.json, which cannot exist — so EVERY subpath import
+	// fails and the styles bundle dies, taking the theme layer with it.
+	//
+	// A scoped name is the FIRST TWO segments (@scope/name); an unscoped name
+	// is the first. Everything after that is a path inside the package and is
+	// resolved directly — it names a file, so there is nothing to negotiate and
+	// no style entry to consult.
+	const segments = id.split("/");
+	const nameLength = id.startsWith("@") ? 2 : 1;
+	const packageName = segments.slice(0, nameLength).join("/");
+	const subpath = segments.slice(nameLength).join("/");
+
+	// Find node_modules/<packageName>/package.json by walking upward from the
+	// importing file's dir then cwd. Bun.resolve is not used: it hands back
+	// whatever the package's main is — for a normal JS package a .js entry,
+	// not the declared stylesheet — and an `exports` allow-list blocks the
+	// package.json subpath on exactly the CSS-only packages this must serve.
 	const tried: string[] = [];
 	for (const root of [base, cwd]) {
 		let dir = root;
 		for (;;) {
-			const pkgPath = join(dir, "node_modules", id, "package.json");
+			const pkgPath = join(dir, "node_modules", packageName, "package.json");
 			if (await Bun.file(pkgPath).exists()) {
+				const pkgDir = dirname(pkgPath);
 				const pkg = await Bun.file(pkgPath).json();
-				const entry: string | undefined =
-					pkg.exports?.["."]?.style ?? pkg.style;
+				if (subpath) {
+					// THE EXPORTS MAP IS THE AUTHORITY ON WHERE A SUBPATH LIVES,
+					// and it commonly REMAPS. `@teamscala/ui-foundation` publishes
+					// "./theme/styles.css" -> "./src/theme/styles.css", so resolving
+					// the subpath literally against the package root looks for a
+					// file that has never existed there. Consult exports first and
+					// fall back to the literal path only for a package that
+					// declares none.
+					const exported = pkg.exports?.[`./${subpath}`];
+					const mapped: string | undefined =
+						typeof exported === "string"
+							? exported
+							: (exported?.style ?? exported?.default);
+					const r = resolve(pkgDir, mapped ?? subpath);
+					if (!(await Bun.file(r).exists())) {
+						throw new Error(
+							`style import "${id}" resolves to ${r}, which does not exist` +
+								(mapped
+									? ` (exports maps "./${subpath}" to "${mapped}")`
+									: ` (${packageName} declares no exports entry for "./${subpath}")`),
+						);
+					}
+					return { path: r, base: dirname(r), content: await Bun.file(r).text() };
+				}
+				// No subpath: the package itself must declare its stylesheet.
+				const entry: string | undefined = pkg.exports?.["."]?.style ?? pkg.style;
 				if (!entry) {
 					throw new Error(
 						`style import "${id}" resolved to ${pkgPath} but the package declares no style entry (exports["."].style / style) — not a stylesheet package`,
 					);
 				}
-				const r = resolve(dirname(pkgPath), entry);
+				const r = resolve(pkgDir, entry);
 				return { path: r, base: dirname(r), content: await Bun.file(r).text() };
 			}
 			tried.push(pkgPath);
@@ -75,7 +114,7 @@ async function resolveStylesheetRaw(
 		}
 	}
 	throw new Error(
-		`style import "${id}" unresolved — no node_modules/${id}/package.json found walking up from ${base} or ${cwd} (${tried.length} location(s) tried)`,
+		`style import "${id}" unresolved — no node_modules/${packageName}/package.json found walking up from ${base} or ${cwd} (${tried.length} location(s) tried)`,
 	);
 }
 

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

@@ -52,8 +52,7 @@ describe("interpolateMeta (resolver_input ref contract)", () => {
 });
 
 describe("resource-loader model capability", () => {
-	test("an optional source still refuses a model absent from the generated client", async () => {
-		const original = isServerClientRegistered() ? getServerClient() : null;
+	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(
@@ -104,3 +103,224 @@ describe("resource-loader model capability", () => {
 		}
 	});
 });
+
+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 });
+	});
+});

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

@@ -12,6 +12,7 @@
  */
 
 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";
 
@@ -120,7 +121,7 @@ function toSelectMap(
  * hardcoded if(resolver_fn==='X') chain — adding a resolver is now a registry_edit row.
  */
 async function resolveByResolverFn(
-	slug: string,
+	slug: ResolverFnKey,
 	input: Record<string, unknown>,
 	params: Record<string, unknown>,
 ): Promise<unknown> {
@@ -145,6 +146,40 @@ async function resolveByResolverFn(
 	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>,
@@ -156,6 +191,14 @@ async function resolveSource(
 		case "orpc":
 		case "prisma": {
 			if (!source.model) return null;
+			if (!source.optional && source.where) {
+				const broken = unresolvedTemplateRefs(source.where, params, resolved);
+				if (broken.length > 0) {
+					throw new Error(
+						`[resource_loader] required source "${source.key}": where ref(s) ${broken.map((ref) => `:${ref}`).join(", ")} 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,
@@ -187,7 +230,11 @@ async function resolveSource(
 					) as Record<string, unknown>)
 				: {};
 
-			return resolveByResolverFn(source.resolver_fn ?? "", input, params);
+			return resolveByResolverFn(
+				source.resolver_fn as ResolverFnKey,
+				input,
+				params,
+			);
 		}
 		default:
 			throw new Error(

package/src/resolve-service-context.ts

@@ -27,13 +27,34 @@ 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,
 	});
-	registerPrismaClient(dbClient.prisma as never as PrismaClient);
+	// 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);