@teamscala/service-boot 0.23.438 → 0.23.440

package/package.json

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

package/src/fn-routers/public-assessment-router.test.ts

@@ -22,6 +22,7 @@ interface CapturedEmail {
 	text: string;
 }
 
+let capturedResponseRow: Record<string, unknown> | null = null;
 let capturedEmail: CapturedEmail | null = null;
 let emailResolve: ((email: CapturedEmail) => void) | null = null;
 let capturedEvent: { kind: string; payload: Record<string, unknown> } | null = null;
@@ -197,7 +198,10 @@ function makeFakePrisma() {
 		// client_database deliberately absent — the quiz prisma client is
 		// scoped without it, so the CRM branch must skip without error.
 		assessment_responses: {
-			create: async () => ({ id: "resp-1" }),
+			create: async (args: { data: Record<string, unknown> }) => {
+				capturedResponseRow = args?.data ?? null;
+				return { id: "resp-1" };
+			},
 		},
 		email_send_log: {
 			create: async () => ({}),
@@ -218,7 +222,10 @@ type SubmitHandler = (opts: {
 	context: { prisma: unknown; headers: Headers };
 }) => Promise<Record<string, unknown>>;
 
-async function submitWith45(headers = new Headers()) {
+async function submitWith45(
+	headers = new Headers(),
+	extraInput: Record<string, unknown> = {},
+) {
 	// The raw handler under ~orpc only reads { input, context }; the other
 	// ProcedureHandlerOptions fields are middleware plumbing this procedure
 	// (no middlewares) never touches, so the narrowed call shape is cast.
@@ -229,6 +236,7 @@ async function submitWith45(headers = new Headers()) {
 			firstName: "Alex Reader",
 			email: "alex@example.com",
 			answers: answersForScore45(),
+			...extraInput,
 		},
 		context: { prisma: makeFakePrisma(), headers },
 	});
@@ -237,6 +245,7 @@ async function submitWith45(headers = new Headers()) {
 beforeEach(() => {
 	capturedEmail = null;
 	capturedEvent = null;
+	capturedResponseRow = null;
 	brandRowStub = null;
 });
 
@@ -374,3 +383,55 @@ describe("publicAssessment.submit — email band single-sourced from stage_bands
 		expect(email.html).not.toMatch(/<img/i);
 	});
 });
+
+describe("prospect segmentation fields are captured without touching the score", () => {
+	const SEGMENTATION = {
+		linkedinUrl: "https://www.linkedin.com/in/alex-reader",
+		website: "https://alexreader.example",
+		teamSize: "Me + team of 2–5",
+	};
+
+	test("all three persist to their own columns", async () => {
+		await submitWith45(new Headers(), SEGMENTATION);
+		expect(capturedResponseRow?.linkedin_url).toBe(SEGMENTATION.linkedinUrl);
+		expect(capturedResponseRow?.website).toBe(SEGMENTATION.website);
+		expect(capturedResponseRow?.team_size).toBe(SEGMENTATION.teamSize);
+	});
+
+	test("the Authority Index is IDENTICAL with and without them", async () => {
+		// The operator's binding constraint: these are segmentation only and must
+		// not move the score. Asserting the same answers produce the same score
+		// either way is the only check that actually proves it — asserting the
+		// columns were written says nothing about the scorer.
+		const without = (await submitWith45()) as {
+			totalScore: number;
+			categoryScores: Record<string, number>;
+		};
+		const withFields = (await submitWith45(
+			new Headers(),
+			SEGMENTATION,
+		)) as { totalScore: number; categoryScores: Record<string, number> };
+
+		expect(withFields.totalScore).toBe(without.totalScore);
+		expect(withFields.categoryScores).toEqual(without.categoryScores);
+	});
+
+	test("omitting them writes null, not empty string", async () => {
+		// A skipped optional field must be absent in the data, so segmentation
+		// queries can tell "not asked" from "answered blank".
+		await submitWith45();
+		expect(capturedResponseRow?.linkedin_url).toBeNull();
+		expect(capturedResponseRow?.website).toBeNull();
+		expect(capturedResponseRow?.team_size).toBeNull();
+	});
+
+	test("the existing answers payload is unchanged by their presence", async () => {
+		// Guards the other direction: segmentation must not leak into `answers`,
+		// which is the set the scorer reads.
+		await submitWith45(new Headers(), SEGMENTATION);
+		const answers = capturedResponseRow?.answers as Array<{ question_id: string }>;
+		expect(answers).toHaveLength(20);
+		expect(JSON.stringify(answers)).not.toContain("linkedin");
+		expect(JSON.stringify(answers)).not.toContain("team of 2");
+	});
+});

package/src/fn-routers/public-assessment-router.ts

@@ -41,6 +41,10 @@ const submitSchema = v.object({
 	email: v.string(),
 	company: v.optional(v.string()),
 	phone: v.optional(v.string()),
+	// Prospect segmentation, captured at the company step. All optional and all
+	// written to their own columns — none is an input to scoring, which reads
+	// `answers` alone.
+	linkedinUrl: v.optional(v.string()),
 	website: v.optional(v.string()),
 	industry: v.optional(v.string()),
 	teamSize: v.optional(v.string()),
@@ -178,6 +182,9 @@ export const publicAssessmentRouter = {
 					first_name: firstName,
 					last_name: lastName,
 					company: input.company ?? null,
+					linkedin_url: input.linkedinUrl ?? null,
+					website: input.website ?? null,
+					team_size: input.teamSize ?? null,
 					total_score: totalScore,
 					category_scores: categoryScores,
 					answers: input.answers.map((a) => ({

package/src/mount-orpc-router.ts

@@ -12,6 +12,7 @@
 import { join } from "node:path";
 import { getAppLogger } from "@teamscala/logger/app-loggers";
 import { registerFnRouters } from "./fn-routers/index.ts";
+import type { InjectedDb8 } from "@teamscala/orpc/configure";
 import type { Hono } from "hono";
 import { bodyLimit } from "hono/body-limit";
 
@@ -70,6 +71,29 @@ export async function mountOrpcRouter(
 			"@teamscala/orpc/configure"
 		);
 
+		// Coexistence (Prisma 8 migration): create the v8 chained client when
+		// the shared platform contract ships inside @teamscala/db. Absence is
+		// the EXPECTED state for services that have not migrated — db8 stays
+		// undefined and v7 procedures are untouched. One boot-time creation,
+		// closed over by the request handler (connects lazily on first query).
+		let db8: InjectedDb8 | undefined;
+		try {
+			if (process.env.DATABASE_URL) {
+				const { createDbClientV8 } = await import(
+					"@teamscala/db/create-db-client-v8"
+				);
+				db8 = (await createDbClientV8({
+					connectionString: process.env.DATABASE_URL,
+					serviceName: serviceSlug,
+				})) as never;
+			}
+		} catch (err) {
+			log.info(
+				`[scala-install:${serviceSlug}] db8 (Prisma 8 chained client) unavailable: ${err instanceof Error ? err.message : err} — serving v7 procedures only`,
+			);
+			db8 = undefined;
+		}
+
 		// Bridge the composed router into tool-executor so in-process tool
 		// dispatch (chat agents' work_items/meetings/agreements/proposals
 		// tools, etc.) resolves against this service's ORPC router + Prisma
@@ -160,7 +184,7 @@ export async function mountOrpcRouter(
 				const prisma = getConfiguredPrisma();
 				const result = await handler.handle(c.req.raw, {
 					prefix: "/api/rpc",
-					context: { prisma, headers: c.req.raw.headers, resolveUser },
+					context: { prisma, db8, headers: c.req.raw.headers, resolveUser },
 				});
 				if (!result?.matched) return c.notFound();
 				return result.response;