@teamscala/service-boot 0.23.457 → 0.23.458

package/package.json

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

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

@@ -104,6 +104,116 @@ 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

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);