@teamscala/service-boot 0.23.284

package/src/register-registry-page-route/meta-title.ts

@@ -0,0 +1,73 @@
+/**
+ * @system ui-service-boot
+ * @status handwritten @indivisible-unit
+ * @edit edit directly
+ *
+ * Meta/title helpers for the route registrar: interpolate the route's
+ * meta_context against the resolved graph, and resolve a curated
+ * page_meta_template title. Extracted from register-registry-page-route.ts.
+ */
+import { interpolateMeta } from "../resolve-from-loader-config.ts";
+import { getEntriesByType } from "@teamscala/db/registry/accessors";
+
+export function buildMetaFromContext(
+	metaContext: Record<string, Record<string, string>> | undefined,
+	resolved: Record<string, unknown>,
+): Record<string, unknown> {
+	if (!metaContext) return {};
+	return interpolateMeta(metaContext as Record<string, unknown>, resolved);
+}
+
+export function resolveTemplateTitle(
+	service: string,
+	resolved: Record<string, unknown>,
+): string | undefined {
+	const rows = getEntriesByType("page_meta_template") as Array<{
+		slug: string;
+		config: Record<string, unknown>;
+	}>;
+	const bySlug = new Map<string, Record<string, unknown>>();
+	for (const row of rows) {
+		bySlug.set(row.slug, row.config);
+	}
+	const merged = (bySlug.get("default") ?? null) as Record<string, unknown> | null;
+	const serviceTmpl = (bySlug.get(service) ?? null) as Record<string, unknown> | null;
+	const tmpl = serviceTmpl ?? merged;
+	if (!tmpl) return undefined;
+	const titleTemplate = tmpl.titleTemplate as string | undefined;
+	if (!titleTemplate) return undefined;
+	const brand = (resolved.brand as Record<string, unknown>) ?? {};
+	const website = (resolved.website as Record<string, unknown>) ?? {};
+	const page = (resolved.page as Record<string, unknown>) ?? {};
+	// The full placeholder set the curated resource templates use:
+	// {org.name}, {website.name}, {page.name}, {form.name}, {quiz.name},
+	// {proposal.name}, {agent.name}. Previously only {org.name} resolved, so
+	// every resource template ("{agent.name} — {org.name}", "{form.name} by
+	// {org.name}") shipped with a blank subject. Resolving the graph here is
+	// the executor half of composePageTitle (business-logic-is-rows-plus-
+	// executors): the template ROWS carry the shape, this carries the values.
+	const context: Record<string, unknown> = {
+		org: { name: (brand.companyName as string) || undefined },
+		website: { name: (website.name as string) || undefined },
+		page: { name: (page.name as string) || undefined },
+		form: { name: ((resolved.form as Record<string, unknown>)?.name as string) || undefined },
+		quiz: { name: ((resolved.quiz as Record<string, unknown>)?.name as string) || undefined },
+		proposal: {
+			name: ((resolved.proposal as Record<string, unknown>)?.name as string) || undefined,
+		},
+		agent: { name: ((resolved.agent as Record<string, unknown>)?.name as string) || undefined },
+	};
+	const result = titleTemplate.replace(/\{([^}]+)\}/g, (_m, path: string) => {
+		const keys = path.trim().split(".");
+		let cur: unknown = context;
+		for (const k of keys) {
+			if (cur && typeof cur === "object") {
+				cur = (cur as Record<string, unknown>)[k];
+			} else {
+				return "";
+			}
+		}
+		return cur === null || cur === undefined ? "" : String(cur);
+	});
+	return result || undefined;
+}

package/src/register-registry-page-route/proposal-approval-email-token.ts

@@ -0,0 +1,78 @@
+/**
+ * @system ui-service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Resolve the `{{approvalEmail}}` token on a proposal page, after pageData is
+ * built.
+ *
+ * Split from proposal-post-processors.ts, which single-purpose-file correctly
+ * flagged as two unrelated export groups. This unit is an async ORPC lookup
+ * that rewrites button props; its former co-tenants are synchronous brand
+ * stamping that touch no network. Sharing a file made an I/O-bound resolver
+ * look like a pure formatter.
+ */
+import { getServerClient } from "../page-server-orpc/server-client.ts";
+
+
+/**
+ * Resolve the `{{approvalEmail}}` placeholder in a proposal page's button props
+ * (e.g. the Approve CTA) in place. Routing: the organisation's registered
+ * company email FIRST (organisation_profile.contact_email, already resolved
+ * into pageData.brand.contactEmail); the proposal creator's user email only as
+ * a fallback when the org has none — so a cloned proposal can never carry a
+ * stale hard-coded address. The creator lookup is null-safe and adds no user
+ * exposure: it resolves only where the in-process ORPC client exposes `user`
+ * (super-admin), degrading to the org email elsewhere. Called only for proposal
+ * pages; other registry pages are untouched.
+ */
+
+export async function applyApprovalEmailToken(
+	pageData: Record<string, unknown>,
+	proposal: { created_by?: string } | undefined,
+): Promise<void> {
+	const brand = pageData.brand as { contactEmail?: string | null } | undefined;
+	let approvalEmail: string | null = brand?.contactEmail ?? null;
+	const createdBy = proposal?.created_by;
+	if (!approvalEmail && createdBy && createdBy !== "system") {
+		try {
+			const client = getServerClient() as {
+				user?: {
+					findFirst?: (
+						a: unknown,
+					) => Promise<{ email?: string | null } | null>;
+				};
+			};
+			const creator = await client.user?.findFirst?.({
+				where: { id: createdBy },
+				select: { email: true },
+			});
+			if (creator?.email) approvalEmail = creator.email;
+		} catch {}
+	}
+	if (!approvalEmail) return;
+	const email = approvalEmail;
+	const walk = (value: unknown): unknown => {
+		if (typeof value === "string")
+			return value.split("{{approvalEmail}}").join(email);
+		if (Array.isArray(value)) return value.map(walk);
+		if (value && typeof value === "object") {
+			const obj = value as Record<string, unknown>;
+			for (const key of Object.keys(obj)) obj[key] = walk(obj[key]);
+			return obj;
+		}
+		return value;
+	};
+	const regions = pageData.regions as
+		| { puckData?: { content?: unknown[] } }[]
+		| undefined;
+	if (Array.isArray(regions)) {
+		for (const region of regions) {
+			const content = region?.puckData?.content;
+			if (Array.isArray(content)) for (const block of content) walk(block);
+		}
+	}
+	const single = (pageData.puckData as { content?: unknown[] } | undefined)
+		?.content;
+	if (Array.isArray(single)) for (const block of single) walk(block);
+}

package/src/register-registry-page-route/proposal-brand-stamping.ts

@@ -0,0 +1,60 @@
+/**
+ * @system ui-service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Stamp partner and client brand assets onto a proposal page's pageData, after
+ * it is built.
+ *
+ * Split from proposal-post-processors.ts (single-purpose-file: two unrelated
+ * export groups). Both helpers here are synchronous, take an already-resolved
+ * loader-graph org, and only map a logo/colour onto pageData — no network, no
+ * ORPC. The approval-email token resolver they used to share a file with is an
+ * async ORPC lookup, which is the distinction that was invisible while they sat
+ * together.
+ */
+import { toAssetPath } from "@teamscala/formatters/asset-url";
+
+/**
+ * Stash a proposal's connected partner logo/colour on `pageData` from the
+ * `partnerOrg` loader source (`crm_organisations` loaded by the proposal's
+ * `partner_id`, via the SAME proven ORPC loader path that loads the proposal
+ * itself). resolve-page-brand (service-runtime) prefers `pageData.partnerLogo`
+ * over any inline body-Hero prop and fans it into the shared `/header` so a
+ * `source: "partner"` OrgLogo fills automatically — the partner logo lives on
+ * the CRM record, never duplicated per proposal. No partner → partnerOrg is
+ * null → nothing set → the partner logo block renders blank. Reading the
+ * already-resolved loader value (not a second hand-rolled getServerClient call)
+ * is what makes this reliable: the earlier direct `crm_organisations.findFirst`
+ * with a Prisma-style object `select` resolved intermittently/never against the
+ * generated ORPC, leaving the header partner blank (2026-06-12).
+ */
+export function applyPartnerBrand(
+	pageData: Record<string, unknown>,
+	partnerOrg:
+		| { logo_url?: string | null; brand_primary_color?: string | null }
+		| undefined
+		| null,
+): void {
+	if (!partnerOrg) return;
+	if (partnerOrg.logo_url) pageData.partnerLogo = toAssetPath(partnerOrg.logo_url);
+	if (partnerOrg.brand_primary_color)
+		pageData.partnerBrandColor = partnerOrg.brand_primary_color;
+}
+
+/**
+ * Auto-resolve the client's company logo from the `clientOrg` loader source
+ * (contact_id → company_id → crm_organisations.logo_url). Injects into the
+ * Hero block's clientLogo prop when it's empty — no manual logo URL needed
+ * per proposal when the contact's company profile has a logo.
+ */
+export function applyClientLogo(
+	pageData: Record<string, unknown>,
+	clientOrg:
+		| { logo_url?: string | null; name?: string | null }
+		| undefined
+		| null,
+): void {
+	if (!clientOrg?.logo_url) return;
+	pageData.clientLogo = toAssetPath(clientOrg.logo_url);
+}