Scheduling infrastructure for absolutely everyone.
feat: Use `RoutingTraceService` to write assignment reasons (#27225)
Joe Au-Yeung620445d85fe2
diff --git a/apps/web/app/api/routing-forms/queued-response/route.ts b/apps/web/app/api/routing-forms/queued-response/route.tsindex e2f52acfb99..719c3b7cdef 100644--- a/apps/web/app/api/routing-forms/queued-response/route.ts+++ b/apps/web/app/api/routing-forms/queued-response/route.ts@@ -5,6 +5,7 @@ import { z, ZodError } from "zod";import { onSubmissionOfFormResponse } from "@calcom/app-store/routing-forms/lib/formSubmissionUtils";import { getResponseToStore } from "@calcom/app-store/routing-forms/lib/getResponseToStore";import { getSerializableForm } from "@calcom/app-store/routing-forms/lib/getSerializableForm";+import { PrismaPendingRoutingTraceRepository } from "@calcom/features/routing-trace/repositories/PrismaPendingRoutingTraceRepository";import logger from "@calcom/lib/logger";import { safeStringify } from "@calcom/lib/safeStringify";import { RoutingFormResponseRepository } from "@calcom/lib/server/repository/formResponse";@@ -58,6 +59,18 @@ export const queuedResponseHandler = async ({chosenRouteId: queuedFormResponse.chosenRouteId,});+ // Link the pending routing trace to the new formResponseId so it can be found when booking is created+ try {+ const pendingTraceRepo = new PrismaPendingRoutingTraceRepository(prisma);+ await pendingTraceRepo.linkToFormResponse({+ queuedFormResponseId: queuedFormResponse.id,+ formResponseId: formResponse.id,+ });+ } catch (error) {+ // Log but don't fail - trace linking is not critical+ logger.warn("Failed to link pending routing trace to form response", safeStringify(error));+ }+const chosenRoute = serializableForm.routes?.find((r) => r.id === queuedFormResponse.chosenRouteId);await onSubmissionOfFormResponse({form: {diff --git a/packages/app-store/routing-forms/lib/crmRouting/routerGetCrmContactOwnerEmail.ts b/packages/app-store/routing-forms/lib/crmRouting/routerGetCrmContactOwnerEmail.tsindex 863edb3d7cb..4df620448c5 100644--- a/packages/app-store/routing-forms/lib/crmRouting/routerGetCrmContactOwnerEmail.ts+++ b/packages/app-store/routing-forms/lib/crmRouting/routerGetCrmContactOwnerEmail.ts@@ -1,5 +1,6 @@import { getCRMContactOwnerForRRLeadSkip } from "@calcom/app-store/_utils/CRMRoundRobinSkip";import { EventTypeRepository } from "@calcom/features/eventtypes/repositories/eventTypeRepository";+import type { RoutingTraceService } from "@calcom/features/routing-trace/services/RoutingTraceService";import { prisma } from "@calcom/prisma";import { SchedulingType } from "@calcom/prisma/enums";@@ -10,10 +11,12 @@ export default async function routerGetCrmContactOwnerEmail({attributeRoutingConfig,identifierKeyedResponse,action,+ routingTraceService,}: {attributeRoutingConfig: LocalRoute["attributeRoutingConfig"];identifierKeyedResponse: Record<string, string | string[]> | null;action: LocalRoute["action"];+ routingTraceService?: RoutingTraceService;}) {// Check if route is skipping CRM contact checkif (attributeRoutingConfig?.skipContactOwner) return null;@@ -23,7 +26,8 @@ export default async function routerGetCrmContactOwnerEmail({for (const identifier of Object.keys(identifierKeyedResponse)) {const fieldResponse = identifierKeyedResponse[identifier];if (identifier === "email") {- prospectEmail = fieldResponse instanceof Array ? fieldResponse[0] : fieldResponse;+ prospectEmail =+ fieldResponse instanceof Array ? fieldResponse[0] : fieldResponse;break;}}@@ -31,11 +35,15 @@ export default async function routerGetCrmContactOwnerEmail({if (!prospectEmail) return null;// Determine if the action is an event type redirect- if (action.type !== "eventTypeRedirectUrl" || !action.eventTypeId) return null;+ if (action.type !== "eventTypeRedirectUrl" || !action.eventTypeId)+ return null;const eventTypeRepo = new EventTypeRepository(prisma);- const eventType = await eventTypeRepo.findByIdIncludeHostsAndTeam({ id: action.eventTypeId });- if (!eventType || eventType.schedulingType !== SchedulingType.ROUND_ROBIN) return null;+ const eventType = await eventTypeRepo.findByIdIncludeHostsAndTeam({+ id: action.eventTypeId,+ });+ if (!eventType || eventType.schedulingType !== SchedulingType.ROUND_ROBIN)+ return null;const eventTypeMetadata = eventType.metadata;if (!eventTypeMetadata) return null;@@ -53,16 +61,23 @@ export default async function routerGetCrmContactOwnerEmail({};// Determine if there is a CRM option enabled in the chosen routefor (const appSlug of enabledAppSlugs) {- const routingOptions = attributeRoutingConfig?.[appSlug as keyof typeof attributeRoutingConfig];+ const routingOptions =+ attributeRoutingConfig?.[appSlug as keyof typeof attributeRoutingConfig];if (!routingOptions) continue;// See if any options are trueif (Object.values(routingOptions).some((option) => option === true)) {- const appBookingFormHandler = (await import("@calcom/app-store/routing-forms/appBookingFormHandler"))- .default;- const appHandler = appBookingFormHandler[appSlug as keyof typeof appBookingFormHandler];+ const appBookingFormHandler = (+ await import("@calcom/app-store/routing-forms/appBookingFormHandler")+ ).default;+ const appHandler =+ appBookingFormHandler[appSlug as keyof typeof appBookingFormHandler];- const ownerQuery = await appHandler(prospectEmail, attributeRoutingConfig, action.eventTypeId);+ const ownerQuery = await appHandler(+ prospectEmail,+ attributeRoutingConfig,+ action.eventTypeId+ );if (ownerQuery?.email) {contactOwner = { ...ownerQuery, crmAppSlug: appSlug };@@ -72,13 +87,33 @@ export default async function routerGetCrmContactOwnerEmail({}if (!contactOwner || (!contactOwner.email && !contactOwner.recordType)) {- const ownerQuery = await getCRMContactOwnerForRRLeadSkip(prospectEmail, eventTypeMetadata);+ const ownerQuery = await getCRMContactOwnerForRRLeadSkip(+ prospectEmail,+ eventTypeMetadata+ );if (ownerQuery?.email) contactOwner = ownerQuery;}if (!contactOwner) return null;// Check that the contact owner is a part of the event type- if (!eventType.hosts.some((host) => host.user.email === contactOwner.email)) return null;+ if (!eventType.hosts.some((host) => host.user.email === contactOwner.email))+ return null;++ if (routingTraceService && contactOwner.email && contactOwner.crmAppSlug) {+ const salesforceSettings = attributeRoutingConfig?.salesforce;+ routingTraceService.addStep({+ domain: contactOwner.crmAppSlug,+ step: `${contactOwner.crmAppSlug}_assignment`,+ data: {+ email: contactOwner.email,+ recordType: contactOwner.recordType,+ recordId: contactOwner.recordId,+ crmAppSlug: contactOwner.crmAppSlug,+ rrSkipToAccountLookupField: salesforceSettings?.rrSkipToAccountLookupField,+ rrSKipToAccountLookupFieldName: salesforceSettings?.rrSKipToAccountLookupFieldName,+ },+ });+ }return contactOwner;}diff --git a/packages/features/bookings/lib/service/RegularBookingService.ts b/packages/features/bookings/lib/service/RegularBookingService.tsindex f6506bbd0e9..6ce8b12347b 100644--- a/packages/features/bookings/lib/service/RegularBookingService.ts+++ b/packages/features/bookings/lib/service/RegularBookingService.ts@@ -46,6 +46,7 @@ import { BookingEmailAndSmsTasker } from "@calcom/features/bookings/lib/tasker/Bimport { getSpamCheckService } from "@calcom/features/di/watchlist/containers/SpamCheckService.container";import { CreditService } from "@calcom/features/ee/billing/credit-service";import { getBookerBaseUrl } from "@calcom/features/ee/organizations/lib/getBookerUrlServer";+import { getRoutingTraceService } from "@calcom/features/routing-trace/di/RoutingTraceService.container";import AssignmentReasonRecorder from "@calcom/features/ee/round-robin/assignmentReason/AssignmentReasonRecorder";import { BookingLocationService } from "@calcom/features/ee/round-robin/lib/bookingLocationService";import { getAllWorkflowsFromEventType } from "@calcom/features/ee/workflows/lib/getAllWorkflowsFromEventType";@@ -1945,25 +1946,22 @@ async function handler(}// If it's a round robin event, record the reason for the host assignment- if (eventType.schedulingType === SchedulingType.ROUND_ROBIN) {- if (reqBody.crmOwnerRecordType && reqBody.crmAppSlug && contactOwnerEmail && routingFormResponseId) {- assignmentReason = await AssignmentReasonRecorder.CRMOwnership({- bookingId: booking.id,- crmAppSlug: reqBody.crmAppSlug,- teamMemberEmail: contactOwnerEmail,- recordType: reqBody.crmOwnerRecordType,- routingFormResponseId,- recordId: crmRecordId,- });- } else if (routingFormResponseId && teamId) {- assignmentReason = await AssignmentReasonRecorder.routingFormRoute({+ if (eventType.schedulingType === SchedulingType.ROUND_ROBIN && routingFormResponseId) {+ try {+ const routingTraceService = getRoutingTraceService();+ const result = await routingTraceService.processForBooking({+ formResponseId: routingFormResponseId,bookingId: booking.id,- routingFormResponseId,- organizerId: organizerUser.id,- teamId,+ bookingUid: booking.uid,+ organizerEmail: organizerUser.email,isRerouting: !!reroutingFormResponses,reroutedByEmail: reqBody.rescheduledBy,});+ if (result?.assignmentReason) {+ assignmentReason = result.assignmentReason;+ }+ } catch (error) {+ criticalLogger.warn("Failed to process routing trace", { error });}}diff --git a/packages/features/routing-forms/lib/findTeamMembersMatchingAttributeLogic.ts b/packages/features/routing-forms/lib/findTeamMembersMatchingAttributeLogic.tsindex d62fecf35aa..42d373555b8 100644--- a/packages/features/routing-forms/lib/findTeamMembersMatchingAttributeLogic.ts+++ b/packages/features/routing-forms/lib/findTeamMembersMatchingAttributeLogic.ts@@ -6,6 +6,11 @@ import { Utils as QbUtils } from "react-awesome-query-builder/lib";import { acrossQueryValueCompatiblity, raqbQueryValueUtils } from "@calcom/app-store/_utils/raqb/raqbUtils";import type { Attribute } from "@calcom/app-store/routing-forms/types/types";import { getAttributesAssignmentData } from "@calcom/features/attributes/lib/getAttributes";+import type { RoutingTraceService } from "@calcom/features/routing-trace/services/RoutingTraceService";+import {+ ROUTING_TRACE_DOMAINS,+ ROUTING_TRACE_STEPS,+} from "@calcom/features/routing-trace/services/RoutingTraceService";import { RaqbLogicResult } from "@calcom/lib/raqb/evaluateRaqbLogic";import jsonLogic from "@calcom/lib/raqb/jsonLogic";import type { dynamicFieldValueOperands, AttributesQueryValue } from "@calcom/lib/raqb/types";@@ -130,6 +135,136 @@ function buildTroubleshooterData({ type, data }: { type: TroubleshooterCase; dat};}+/**+ * Checks if a string is a field template placeholder (e.g., "{field:uuid}")+ */+function isFieldTemplate(str: string): boolean {+ const trimmedStr = str.trim();+ return trimmedStr.startsWith("{field:") && trimmedStr.endsWith("}");+}++/**+ * Extracts field ID from a field template string+ */+function extractFieldIdFromTemplate(template: string): string | null {+ const trimmedTemplate = template.trim();+ if (!isFieldTemplate(trimmedTemplate)) return null;+ return trimmedTemplate.slice(7, -1);+}++/**+ * Resolves a field template to its actual value from the form response+ */+function resolveFieldTemplateValue(+ value: string,+ dynamicFieldValueOperands?: dynamicFieldValueOperands+): string {+ if (!isFieldTemplate(value) || !dynamicFieldValueOperands) {+ return value;+ }++ const fieldId = extractFieldIdFromTemplate(value);+ if (!fieldId) {+ return value;+ }++ const { fields, response } = dynamicFieldValueOperands;+ const field = fields.find((f) => f.id === fieldId);++ if (!field) {+ // Field definition not found - return original template+ return value;+ }++ const fieldResponse = response[field.id];+ if (!fieldResponse) {+ // Field not in response object - return original template+ return value;+ }++ const fieldValue = fieldResponse.value;+ if (fieldValue === null || fieldValue === undefined || fieldValue === "") {+ return "(empty)";+ }++ if (Array.isArray(fieldValue)) {+ return fieldValue.join(", ");+ }++ return String(fieldValue);+}++/**+ * Extracts attribute name/value pairs from a resolved attributesQueryValue.+ * This is used to build the assignment reason string.+ */+function extractAttributeRoutingDetails({+ resolvedAttributesQueryValue,+ attributesOfTheOrg,+ dynamicFieldValueOperands,+}: {+ resolvedAttributesQueryValue: AttributesQueryValue | null;+ attributesOfTheOrg: Attribute[];+ dynamicFieldValueOperands?: dynamicFieldValueOperands;+}): Array<{ attributeName: string; attributeValue: string }> {+ if (!resolvedAttributesQueryValue) {+ return [];+ }++ if (!raqbQueryValueUtils.isQueryValueARuleGroup(resolvedAttributesQueryValue as JsonTree)) {+ return [];+ }++ const children1 = resolvedAttributesQueryValue.children1;+ if (!children1) {+ return [];+ }++ const result: Array<{ attributeName: string; attributeValue: string }> = [];++ for (const ruleId of Object.keys(children1)) {+ const rule = children1[ruleId];+ // Check if it's a rule (has properties with field)+ if (rule.type !== "rule" || !rule.properties) {+ continue;+ }++ const properties = rule.properties;+ const fieldId = properties.field;+ const value = properties.value;++ if (!fieldId || !value || value[0] === null || value[0] === undefined) {+ continue;+ }++ const attribute = attributesOfTheOrg.find((attr) => attr.id === fieldId);+ if (!attribute) {+ continue;+ }++ const attributeValueString = (() => {+ const firstValue = value[0];+ if (Array.isArray(firstValue)) {+ // Handle array values - resolve any field templates within+ const resolvedValues = firstValue.map((v) =>+ typeof v === "string" ? resolveFieldTemplateValue(v, dynamicFieldValueOperands) : String(v)+ );+ return resolvedValues.join(", ");+ }+ const stringValue = String(firstValue);+ // Resolve field template if present+ return resolveFieldTemplateValue(stringValue, dynamicFieldValueOperands);+ })();++ result.push({+ attributeName: attribute.name,+ attributeValue: attributeValueString,+ });+ }++ return result;+}+async function getLogicResultForAllMembers({teamMembersWithAttributeOptionValuePerAttribute,@@ -193,6 +328,7 @@ async function runAttributeLogic(data: RunAttributeLogicData, options: RunAttribreturn {logicBuildingWarnings: null,teamMembersMatchingAttributeLogic: null,+ resolvedAttributesQueryValue: null,timeTaken: null,...buildTroubleshooterData({type: TroubleshooterCase.MATCHES_ALL_MEMBERS_BECAUSE_OF_EMPTY_QUERY_VALUE,@@ -217,6 +353,7 @@ async function runAttributeLogic(data: RunAttributeLogicData, options: RunAttribreturn {teamMembersMatchingAttributeLogic: null,logicBuildingWarnings: null,+ resolvedAttributesQueryValue: attributesQueryValue,timeTaken: {ttgetAttributesQueryBuilderConfigHavingListofLabels,},@@ -256,6 +393,7 @@ async function runAttributeLogic(data: RunAttributeLogicData, options: RunAttribreturn {teamMembersMatchingAttributeLogic,logicBuildingWarnings,+ resolvedAttributesQueryValue: attributesQueryValue,timeTaken: {ttgetAttributesQueryBuilderConfigHavingListofLabels,ttTeamMembersMatchingAttributeLogic,@@ -322,15 +460,18 @@ export async function findTeamMembersMatchingAttributeLogic(fallbackAttributesQueryValue?: AttributesQueryValue | null;dynamicFieldValueOperands?: dynamicFieldValueOperands;isPreview?: boolean;+ routeName?: string;+ routeIsFallback?: boolean;},options: {enablePerf?: boolean;concurrency?: number;enableTroubleshooter?: boolean;+ routingTraceService?: RoutingTraceService;} = {}) {// Higher value of concurrency might not be performant as it might overwhelm the system. So, use a lower value as default.- const { enablePerf = false, concurrency = 2, enableTroubleshooter = false } = options;+ const { enablePerf = false, concurrency = 2, enableTroubleshooter = false, routingTraceService } = options;// Any explicit value being passed should cause fallback to be considered. Even undefinedconst considerFallback = "fallbackAttributesQueryValue" in data;@@ -342,6 +483,8 @@ export async function findTeamMembersMatchingAttributeLogic(fallbackAttributesQueryValue,dynamicFieldValueOperands,isPreview,+ routeName,+ routeIsFallback,} = data;const {@@ -374,6 +517,7 @@ export async function findTeamMembersMatchingAttributeLogic(timeTaken: teamMembersMatchingMainAttributeLogicTimeTaken,troubleshooter,logicBuildingWarnings: mainAttributeLogicBuildingWarnings,+ resolvedAttributesQueryValue,} = await runMainAttributeLogic({...runAttributeLogicData,@@ -382,14 +526,39 @@ export async function findTeamMembersMatchingAttributeLogic(runAttributeLogicOptions);+ // Helper to add trace step for attribute logic evaluation+ const addTraceStep = (checkedFallback: boolean) => {+ if (routingTraceService) {+ const attributeRoutingDetails = extractAttributeRoutingDetails({+ resolvedAttributesQueryValue,+ attributesOfTheOrg,+ dynamicFieldValueOperands,+ });++ routingTraceService.addStep({+ domain: ROUTING_TRACE_DOMAINS.ROUTING_FORM,+ step: ROUTING_TRACE_STEPS.ATTRIBUTE_LOGIC_EVALUATED,+ data: {+ routeName,+ routeIsFallback,+ checkedFallback,+ attributeRoutingDetails,+ },+ });+ }+ };+// It being null means that no logic was found and thus all members match. In such case, we don't fallback intentionally.// This is the case when user added no rules so, he expects to match all membersif (!teamMembersMatchingMainAttributeLogic) {+ addTraceStep(false);return {teamMembersMatchingAttributeLogic: null,checkedFallback: false,mainAttributeLogicBuildingWarnings,fallbackAttributeLogicBuildingWarnings: [],+ routeName,+ routeIsFallback,timeTaken: {...teamMembersMatchingMainAttributeLogicTimeTaken,ttGetAttributesForLogic,@@ -418,11 +587,14 @@ export async function findTeamMembersMatchingAttributeLogic(runAttributeLogicOptions);+ addTraceStep(true);return {teamMembersMatchingAttributeLogic: teamMembersMatchingFallbackLogic,checkedFallback: true,fallbackAttributeLogicBuildingWarnings,mainAttributeLogicBuildingWarnings,+ routeName,+ routeIsFallback,timeTaken: {...teamMembersMatchingFallbackLogicTimeTaken,ttGetAttributesForLogic,@@ -436,11 +608,14 @@ export async function findTeamMembersMatchingAttributeLogic(};}+ addTraceStep(false);return {teamMembersMatchingAttributeLogic: teamMembersMatchingMainAttributeLogic,checkedFallback: false,mainAttributeLogicBuildingWarnings,fallbackAttributeLogicBuildingWarnings: [],+ routeName,+ routeIsFallback,timeTaken: {...teamMembersMatchingMainAttributeLogicTimeTaken,ttGetAttributesForLogic,diff --git a/packages/features/routing-forms/lib/getRoutedUrl.test.ts b/packages/features/routing-forms/lib/getRoutedUrl.test.tsindex 90632586e89..5f78910addb 100644--- a/packages/features/routing-forms/lib/getRoutedUrl.test.ts+++ b/packages/features/routing-forms/lib/getRoutedUrl.test.ts@@ -1,9 +1,6 @@import "@calcom/lib/__mocks__/logger";import { createHash } from "node:crypto";-import type { GetServerSidePropsContext } from "next";-import { beforeEach, describe, expect, it, vi } from "vitest";-import { getAbsoluteEventTypeRedirectUrlWithEmbedSupport } from "@calcom/app-store/routing-forms/getEventTypeRedirectUrl";import { getResponseToStore } from "@calcom/app-store/routing-forms/lib/getResponseToStore";import { getSerializableForm } from "@calcom/app-store/routing-forms/lib/getSerializableForm";@@ -14,6 +11,8 @@ import { isAuthorizedToViewFormOnOrgDomain } from "@calcom/features/routing-formimport { PrismaRoutingFormRepository } from "@calcom/features/routing-forms/repositories/PrismaRoutingFormRepository";import { UserRepository } from "@calcom/features/users/repositories/UserRepository";import { checkRateLimitAndThrowError } from "@calcom/lib/checkRateLimitAndThrowError";+import type { GetServerSidePropsContext } from "next";+import { beforeEach, describe, expect, it, vi } from "vitest";import { getRoutedUrl } from "./getRoutedUrl";import { getUrlSearchParamsToForward } from "./getUrlSearchParamsToForward";@@ -26,9 +25,11 @@ vi.mock("@calcom/lib/checkRateLimitAndThrowError");vi.mock("@calcom/features/routing-forms/repositories/PrismaRoutingFormRepository");vi.mock("@calcom/features/users/repositories/UserRepository", () => {return {- UserRepository: vi.fn().mockImplementation(function() { return {- enrichUserWithItsProfile: vi.fn(),- }; }),+ UserRepository: vi.fn().mockImplementation(function () {+ return {+ enrichUserWithItsProfile: vi.fn(),+ };+ }),};});vi.mock("@calcom/features/ee/organizations/lib/orgDomains");@@ -44,8 +45,33 @@ vi.mock("@calcom/app-store/routing-forms/enrichFormWithMigrationData", () => ({vi.mock("@calcom/lib/sentryWrapper", () => ({withReporting: (fn: unknown) => fn,}));+vi.mock("@calcom/features/routing-trace/di/RoutingTraceService.container", () => ({+ getRoutingTraceService: vi.fn(() => ({+ addStep: vi.fn(),+ getStepsCount: vi.fn().mockReturnValue(0),+ savePendingRoutingTrace: vi.fn().mockResolvedValue(undefined),+ processForBooking: vi.fn().mockResolvedValue(undefined),+ })),+}));-const mockForm = {+const mockForm: {+ id: string;+ user: { id: number; name: string };+ team: null;+ name: string;+ fields: never[];+ routes: never[];+ userId: number;+ teamId: null;+ createdAt: Date;+ updatedAt: Date;+ description: null;+ enabled: boolean;+ isDefault: boolean;+ fieldsOrder: never[];+ position: number;+ slug: string;+} = {id: "form-id",user: { id: 1, name: "Test User" },team: null,@@ -64,7 +90,12 @@ const mockForm = {slug: "test-form",};-const mockSerializableForm = {+const mockSerializableForm: {+ id: string;+ fields: { id: string; type: string; label: string; identifier: string }[];+ routes: never[];+ user: { id: number };+} = {id: "form-id",fields: [{ id: "email", type: "email", label: "Email", identifier: "email" }],routes: [],@@ -73,7 +104,7 @@ const mockSerializableForm = {const mockContext = (query: Record<string, unknown>,- url = "/link/form-id"+ url: string = "/link/form-id"): Pick<GetServerSidePropsContext, "query" | "req"> => ({query: { form: "form-id", ...query },req: { url },@@ -92,8 +123,7 @@ describe("getRoutedUrl", () => {mockUserRepository.mockImplementation(function () {return {enrichUserWithItsProfile: mockEnrichUserWithItsProfile,- // eslint-disable-next-line @typescript-eslint/no-explicit-any- } as any;+ } as unknown as InstanceType<typeof UserRepository>;});}vi.mocked(isAuthorizedToViewFormOnOrgDomain).mockReturnValue(true);diff --git a/packages/features/routing-forms/lib/getRoutedUrl.ts b/packages/features/routing-forms/lib/getRoutedUrl.tsindex 13d946a92c5..a0d87f26ab7 100644--- a/packages/features/routing-forms/lib/getRoutedUrl.ts+++ b/packages/features/routing-forms/lib/getRoutedUrl.ts@@ -16,6 +16,7 @@ import type { FormResponse } from "@calcom/app-store/routing-forms/types/types";import { orgDomainConfig } from "@calcom/features/ee/organizations/lib/orgDomains";import { isAuthorizedToViewFormOnOrgDomain } from "@calcom/features/routing-forms/lib/isAuthorizedToViewForm";import { PrismaRoutingFormRepository } from "@calcom/features/routing-forms/repositories/PrismaRoutingFormRepository";+import { getRoutingTraceService } from "@calcom/features/routing-trace/di/RoutingTraceService.container";import { UserRepository } from "@calcom/features/users/repositories/UserRepository";import { checkRateLimitAndThrowError } from "@calcom/lib/checkRateLimitAndThrowError";import { HttpError } from "@calcom/lib/http-error";@@ -36,7 +37,9 @@ const querySchema = z}).catchall(z.string().or(z.array(z.string())));-const getDeterministicHashForResponse = (fieldsResponses: Record<string, unknown>) => {+const getDeterministicHashForResponse = (+ fieldsResponses: Record<string, unknown>+) => {const sortedFields = Object.keys(fieldsResponses).sort().reduce((obj: Record<string, unknown>, key) => {@@ -53,7 +56,13 @@ export function hasEmbedPath(pathWithQuery: string) {return onlyPath.endsWith("/embed") || onlyPath.endsWith("/embed/");}-const _getRoutedUrl = async (context: Pick<GetServerSidePropsContext, "query" | "req">, fetchCrm = true) => {+const _getRoutedUrl = async (+ context: Pick<GetServerSidePropsContext, "query" | "req">,+ fetchCrm = true+) => {+ // Initialize trace service for tracking routing decisions+ const routingTraceService = getRoutingTraceService();+const queryParsed = querySchema.safeParse(context.query);const isEmbed = hasEmbedPath(context.req.url || "");const pageProps = {@@ -87,7 +96,9 @@ const _getRoutedUrl = async (context: Pick<GetServerSidePropsContext, "query" |const paramsToBeForwardedAsIs = {...fieldsResponses,// Must be forwarded if present to Booking Page. Setting it explicitly here as it is critical to be present in the URL.- ...(isBookingDryRunParam ? { "cal.isBookingDryRun": isBookingDryRunParam } : null),+ ...(isBookingDryRunParam+ ? { "cal.isBookingDryRun": isBookingDryRunParam }+ : null),};const { currentOrgDomain } = orgDomainConfig(context.req);@@ -95,7 +106,8 @@ const _getRoutedUrl = async (context: Pick<GetServerSidePropsContext, "query" |let timeTaken: Record<string, number | null> = {};const formQueryStart = performance.now();- const form = await PrismaRoutingFormRepository.findFormByIdIncludeUserTeamAndOrg(formId);+ const form =+ await PrismaRoutingFormRepository.findFormByIdIncludeUserTeamAndOrg(formId);timeTaken.formQuery = performance.now() - formQueryStart;if (!form) {@@ -113,7 +125,11 @@ const _getRoutedUrl = async (context: Pick<GetServerSidePropsContext, "query" |timeTaken.profileEnrichment = performance.now() - profileEnrichmentStart;if (- !isAuthorizedToViewFormOnOrgDomain({ user: formWithUserProfile.user, currentOrgDomain, team: form.team })+ !isAuthorizedToViewFormOnOrgDomain({+ user: formWithUserProfile.user,+ currentOrgDomain,+ team: form.team,+ })) {return {notFound: true,@@ -144,10 +160,10 @@ const _getRoutedUrl = async (context: Pick<GetServerSidePropsContext, "query" |let teamMembersMatchingAttributeLogic = null;let formResponseId = null;let attributeRoutingConfig = null;+ let queuedFormResponseId;let crmContactOwnerEmail: string | null = null;let crmContactOwnerRecordType: string | null = null;let crmAppSlug: string | null = null;- let queuedFormResponseId;try {const result = await handleResponse({form: serializableForm,@@ -158,18 +174,31 @@ const _getRoutedUrl = async (context: Pick<GetServerSidePropsContext, "query" |isPreview: isBookingDryRun,queueFormResponse: shouldQueueFormResponse,fetchCrm,+ traceService: isBookingDryRun ? undefined : routingTraceService,});- teamMembersMatchingAttributeLogic = result.teamMembersMatchingAttributeLogic;+ teamMembersMatchingAttributeLogic =+ result.teamMembersMatchingAttributeLogic;formResponseId = result.formResponse?.id;queuedFormResponseId = result.queuedFormResponse?.id;attributeRoutingConfig = result.attributeRoutingConfig;+ crmContactOwnerEmail = result.crmContactOwnerEmail;+ crmContactOwnerRecordType = result.crmContactOwnerRecordType;+ crmAppSlug = result.crmAppSlug;timeTaken = {...timeTaken,...result.timeTaken,};- crmContactOwnerEmail = result.crmContactOwnerEmail;- crmContactOwnerRecordType = result.crmContactOwnerRecordType;- crmAppSlug = result.crmAppSlug;++ // Save the pending trace (trace steps are added inside handleResponse)+ if (!isBookingDryRun) {+ if (formResponseId) {+ await routingTraceService.savePendingRoutingTrace({ formResponseId });+ } else if (queuedFormResponseId) {+ await routingTraceService.savePendingRoutingTrace({+ queuedFormResponseId,+ });+ }+ }} catch (e) {if (e instanceof HttpError || e instanceof TRPCError) {return {@@ -214,17 +243,20 @@ const _getRoutedUrl = async (context: Pick<GetServerSidePropsContext, "query" |formResponse: response,fields: serializableForm.fields,searchParams: new URLSearchParams(- stringify({ ...paramsToBeForwardedAsIs, "cal.action": "eventTypeRedirectUrl" })+ stringify({+ ...paramsToBeForwardedAsIs,+ "cal.action": "eventTypeRedirectUrl",+ })),teamMembersMatchingAttributeLogic,formResponseId: formResponseId ?? null,queuedFormResponseId: queuedFormResponseId ?? null,attributeRoutingConfig: attributeRoutingConfig ?? null,- teamId: form?.teamId,- orgId: form.team?.parentId,crmContactOwnerEmail,crmContactOwnerRecordType,crmAppSlug,+ teamId: form?.teamId,+ orgId: form.team?.parentId,}),isEmbed: pageProps.isEmbed,}),@@ -234,7 +266,9 @@ const _getRoutedUrl = async (context: Pick<GetServerSidePropsContext, "query" |} else if (decidedAction.type === "externalRedirectUrl") {return {redirect: {- destination: `${decidedAction.value}?${stringify(context.query)}&cal.action=externalRedirectUrl`,+ destination: `${decidedAction.value}?${stringify(+ context.query+ )}&cal.action=externalRedirectUrl`,permanent: false,},};diff --git a/packages/features/routing-forms/lib/getUrlSearchParamsToForward.ts b/packages/features/routing-forms/lib/getUrlSearchParamsToForward.tsindex 2252a1a6d35..ee81ef610cf 100644--- a/packages/features/routing-forms/lib/getUrlSearchParamsToForward.ts+++ b/packages/features/routing-forms/lib/getUrlSearchParamsToForward.ts@@ -27,12 +27,12 @@ type GetUrlSearchParamsToForwardOptions = {queuedFormResponseId: string | null;teamMembersMatchingAttributeLogic: number[] | null;attributeRoutingConfig: AttributeRoutingConfig | null;- reroutingFormResponses?: FormResponseValueOnly;- teamId?: number | null;- orgId?: number | null;crmContactOwnerEmail?: string | null;crmContactOwnerRecordType?: string | null;crmAppSlug?: string | null;+ reroutingFormResponses?: FormResponseValueOnly;+ teamId?: number | null;+ orgId?: number | null;};export function getUrlSearchParamsToForward({@@ -43,12 +43,12 @@ export function getUrlSearchParamsToForward({formResponseId,queuedFormResponseId,attributeRoutingConfig,- reroutingFormResponses,- teamId,- orgId,crmContactOwnerEmail,crmContactOwnerRecordType,crmAppSlug,+ reroutingFormResponses,+ teamId,+ orgId,}: GetUrlSearchParamsToForwardOptions) {type Params = Record<string, string | string[]>;const paramsFromResponse: Params = {};@@ -118,9 +118,6 @@ export function getUrlSearchParamsToForward({const allQueryParams: Params = {...(teamId && { ["cal.teamId"]: `${teamId}` }),...(orgId && { ["cal.orgId"]: `${orgId}` }),- ...(crmContactOwnerEmail && { ["cal.crmContactOwnerEmail"]: `${crmContactOwnerEmail}` }),- ...(crmContactOwnerRecordType && { ["cal.crmContactOwnerRecordType"]: `${crmContactOwnerRecordType}` }),- ...(crmAppSlug && { ["cal.crmAppSlug"]: `${crmAppSlug}` }),...paramsFromCurrentUrl,// In case of conflict b/w paramsFromResponse and paramsFromCurrentUrl, paramsFromResponse should win as the booker probably improved upon the prefilled value....paramsFromResponse,@@ -132,6 +129,9 @@ export function getUrlSearchParamsToForward({: null),...(queuedFormResponseId ? { ["cal.queuedFormResponseId"]: queuedFormResponseId } : null),...attributeRoutingConfigParams,+ ...(crmContactOwnerEmail ? { ["cal.crmContactOwnerEmail"]: crmContactOwnerEmail } : null),+ ...(crmContactOwnerRecordType ? { ["cal.crmContactOwnerRecordType"]: crmContactOwnerRecordType } : null),+ ...(crmAppSlug ? { ["cal.crmAppSlug"]: crmAppSlug } : null),...(reroutingFormResponses? { ["cal.reroutingFormResponses"]: JSON.stringify(reroutingFormResponses) }: null),diff --git a/packages/features/routing-forms/lib/handleResponse.ts b/packages/features/routing-forms/lib/handleResponse.tsindex c2e54e84281..bbd1e14e1d9 100644--- a/packages/features/routing-forms/lib/handleResponse.ts+++ b/packages/features/routing-forms/lib/handleResponse.ts@@ -6,6 +6,7 @@ import {type TargetRoutingFormForResponse,} from "@calcom/app-store/routing-forms/lib/formSubmissionUtils";import isRouter from "@calcom/app-store/routing-forms/lib/isRouter";+import type { RoutingTraceService } from "@calcom/features/routing-trace/services/RoutingTraceService";import { emailSchema } from "@calcom/lib/emailSchema";import { HttpError } from "@calcom/lib/http-error";import logger from "@calcom/lib/logger";@@ -29,6 +30,7 @@ const _handleResponse = async ({isPreview,queueFormResponse,fetchCrm,+ traceService,}: {response: Record<string,@@ -45,6 +47,7 @@ const _handleResponse = async ({isPreview: boolean;queueFormResponse?: boolean;fetchCrm?: boolean;+ traceService?: RoutingTraceService;}) => {try {if (!form.fields) {@@ -104,6 +107,7 @@ const _handleResponse = async ({let crmAppSlug: string | null = null;let crmRecordId: string | null = null;let timeTaken: Record<string, number | null> = {};+ let checkedFallback = false;if (chosenRoute) {if (isRouter(chosenRoute)) {throw new HttpError({@@ -121,6 +125,7 @@ const _handleResponse = async ({attributeRoutingConfig: chosenRoute.attributeRoutingConfig,identifierKeyedResponse,action: chosenRoute.action,+ routingTraceService: traceService,}): null;crmContactOwnerEmail = contactOwnerQuery?.email ?? null;@@ -141,9 +146,12 @@ const _handleResponse = async ({fallbackAttributesQueryValue: chosenRoute.fallbackAttributesQueryValue,teamId: formTeamId,orgId: formOrgId,+ routeName: chosenRoute.name,+ routeIsFallback: chosenRoute.isFallback,},{enablePerf: true,+ routingTraceService: traceService,}): null;@@ -161,6 +169,7 @@ const _handleResponse = async ({: null;timeTaken = teamMembersMatchingAttributeLogicWithResult?.timeTaken ?? {};+ checkedFallback = teamMembersMatchingAttributeLogicWithResult?.checkedFallback ?? false;})(),]);@@ -226,6 +235,7 @@ const _handleResponse = async ({? chosenRoute.attributeRoutingConfig: null: null,+ checkedFallback,timeTaken,};} catch (e) {diff --git a/packages/features/routing-trace/di/PendingRoutingTraceRepository.module.ts b/packages/features/routing-trace/di/PendingRoutingTraceRepository.module.tsnew file mode 100644index 00000000000..fdbe68ea88e--- /dev/null+++ b/packages/features/routing-trace/di/PendingRoutingTraceRepository.module.ts@@ -0,0 +1,23 @@+import { bindModuleToClassOnToken, createModule, type ModuleLoader } from "@calcom/features/di/di";+import { moduleLoader as prismaModuleLoader } from "@calcom/features/di/modules/Prisma";++import { PrismaPendingRoutingTraceRepository } from "../repositories/PrismaPendingRoutingTraceRepository";+import { ROUTING_TRACE_DI_TOKENS } from "./tokens";++export const pendingRoutingTraceRepositoryModule = createModule();+const token = ROUTING_TRACE_DI_TOKENS.PENDING_ROUTING_TRACE_REPOSITORY;+const moduleToken = ROUTING_TRACE_DI_TOKENS.PENDING_ROUTING_TRACE_REPOSITORY_MODULE;+const loadModule = bindModuleToClassOnToken({+ module: pendingRoutingTraceRepositoryModule,+ moduleToken,+ token,+ classs: PrismaPendingRoutingTraceRepository,+ dep: prismaModuleLoader,+});++export const moduleLoader: ModuleLoader = {+ token,+ loadModule,+};++export type { PrismaPendingRoutingTraceRepository };diff --git a/packages/features/routing-trace/di/RoutingTraceRepository.module.ts b/packages/features/routing-trace/di/RoutingTraceRepository.module.tsnew file mode 100644index 00000000000..884aac2558e--- /dev/null+++ b/packages/features/routing-trace/di/RoutingTraceRepository.module.ts@@ -0,0 +1,23 @@+import { bindModuleToClassOnToken, createModule, type ModuleLoader } from "@calcom/features/di/di";+import { moduleLoader as prismaModuleLoader } from "@calcom/features/di/modules/Prisma";++import { PrismaRoutingTraceRepository } from "../repositories/PrismaRoutingTraceRepository";+import { ROUTING_TRACE_DI_TOKENS } from "./tokens";++export const routingTraceRepositoryModule = createModule();+const token = ROUTING_TRACE_DI_TOKENS.ROUTING_TRACE_REPOSITORY;+const moduleToken = ROUTING_TRACE_DI_TOKENS.ROUTING_TRACE_REPOSITORY_MODULE;+const loadModule = bindModuleToClassOnToken({+ module: routingTraceRepositoryModule,+ moduleToken,+ token,+ classs: PrismaRoutingTraceRepository,+ dep: prismaModuleLoader,+});++export const moduleLoader: ModuleLoader = {+ token,+ loadModule,+};++export type { PrismaRoutingTraceRepository };diff --git a/packages/features/routing-trace/di/RoutingTraceService.container.ts b/packages/features/routing-trace/di/RoutingTraceService.container.tsnew file mode 100644index 00000000000..7e58a2c05ad--- /dev/null+++ b/packages/features/routing-trace/di/RoutingTraceService.container.ts@@ -0,0 +1,37 @@+import { AssignmentReasonRepository } from "@calcom/features/assignment-reason/repositories/AssignmentReasonRepository";+import { createContainer } from "@calcom/features/di/di";+import prisma from "@calcom/prisma";++import type { IPendingRoutingTraceRepository } from "../repositories/PendingRoutingTraceRepository.interface";+import type { IRoutingTraceRepository } from "../repositories/RoutingTraceRepository.interface";+import { RoutingTraceService } from "../services/RoutingTraceService";+import { moduleLoader as pendingRoutingTraceRepositoryModuleLoader } from "./PendingRoutingTraceRepository.module";+import { moduleLoader as routingTraceRepositoryModuleLoader } from "./RoutingTraceRepository.module";++const routingTraceContainer = createContainer();++function getPendingRoutingTraceRepository(): IPendingRoutingTraceRepository {+ pendingRoutingTraceRepositoryModuleLoader.loadModule(routingTraceContainer);+ return routingTraceContainer.get<IPendingRoutingTraceRepository>(+ pendingRoutingTraceRepositoryModuleLoader.token+ );+}++function getRoutingTraceRepository(): IRoutingTraceRepository {+ routingTraceRepositoryModuleLoader.loadModule(routingTraceContainer);+ return routingTraceContainer.get<IRoutingTraceRepository>(routingTraceRepositoryModuleLoader.token);+}++/**+ * Creates a RoutingTraceService instance with all required repositories.+ * Use this for processing pending traces during booking creation.+ */+export function getRoutingTraceService(): RoutingTraceService {+ return new RoutingTraceService({+ pendingRoutingTraceRepository: getPendingRoutingTraceRepository(),+ routingTraceRepository: getRoutingTraceRepository(),+ assignmentReasonRepository: new AssignmentReasonRepository(prisma),+ });+}++export { RoutingTraceService };diff --git a/packages/features/routing-trace/di/tokens.ts b/packages/features/routing-trace/di/tokens.tsnew file mode 100644index 00000000000..0c185e88539--- /dev/null+++ b/packages/features/routing-trace/di/tokens.ts@@ -0,0 +1,8 @@+export const ROUTING_TRACE_DI_TOKENS = {+ ROUTING_TRACE_SERVICE: Symbol("RoutingTraceService"),+ ROUTING_TRACE_SERVICE_MODULE: Symbol("RoutingTraceServiceModule"),+ PENDING_ROUTING_TRACE_REPOSITORY: Symbol("PendingRoutingTraceRepository"),+ PENDING_ROUTING_TRACE_REPOSITORY_MODULE: Symbol("PendingRoutingTraceRepositoryModule"),+ ROUTING_TRACE_REPOSITORY: Symbol("RoutingTraceRepository"),+ ROUTING_TRACE_REPOSITORY_MODULE: Symbol("RoutingTraceRepositoryModule"),+};diff --git a/packages/features/routing-trace/repositories/PendingRoutingTraceRepository.interface.ts b/packages/features/routing-trace/repositories/PendingRoutingTraceRepository.interface.tsnew file mode 100644index 00000000000..d4406a756d0--- /dev/null+++ b/packages/features/routing-trace/repositories/PendingRoutingTraceRepository.interface.ts@@ -0,0 +1,43 @@+import type {+ BaseRoutingTrace,+ RoutingTrace,+} from "./RoutingTraceRepository.interface";++export interface RoutingTraceWithQueuedResponse extends BaseRoutingTrace {+ queuedFormResponseId: string;+}++export interface PendingRoutingTraceRecord {+ id: string;+ createdAt: Date;+ trace: RoutingTrace;+ formResponseId: number | null;+ queuedFormResponseId: string | null;+}++export interface IPendingRoutingTraceRepository {+ create(args: IPendingRoutingTraceRepositoryCreateArgs): Promise<void>;+ findByFormResponseId(formResponseId: number): Promise<PendingRoutingTraceRecord | null>;+ findByQueuedFormResponseId(queuedFormResponseId: string): Promise<PendingRoutingTraceRecord | null>;+ /** Link a pending trace (created with queuedFormResponseId) to a formResponseId when the queued response is processed */+ linkToFormResponse(args: {+ queuedFormResponseId: string;+ formResponseId: number;+ }): Promise<void>;+}++interface BaseCreateArgs {+ trace: RoutingTrace;+}++interface CreateWithFormResponse extends BaseCreateArgs {+ formResponseId: number;+}++interface CreateWithQueuedFormResponse extends BaseCreateArgs {+ queuedFormResponseId: string;+}++export type IPendingRoutingTraceRepositoryCreateArgs =+ | CreateWithFormResponse+ | CreateWithQueuedFormResponse;diff --git a/packages/features/routing-trace/repositories/PrismaPendingRoutingTraceRepository.test.ts b/packages/features/routing-trace/repositories/PrismaPendingRoutingTraceRepository.test.tsnew file mode 100644index 00000000000..ceb0c1836b4--- /dev/null+++ b/packages/features/routing-trace/repositories/PrismaPendingRoutingTraceRepository.test.ts@@ -0,0 +1,208 @@+import type { PrismaClient } from "@calcom/prisma";+import { beforeEach, describe, expect, it, vi } from "vitest";++import { PrismaPendingRoutingTraceRepository } from "./PrismaPendingRoutingTraceRepository";++describe("PrismaPendingRoutingTraceRepository", () => {+ let repository: PrismaPendingRoutingTraceRepository;++ const mockPrisma = {+ pendingRoutingTrace: {+ create: vi.fn(),+ findUnique: vi.fn(),+ },+ } as unknown as PrismaClient;++ beforeEach(() => {+ vi.clearAllMocks();+ repository = new PrismaPendingRoutingTraceRepository(mockPrisma);+ });++ describe("create", () => {+ it("should create a pending routing trace with formResponseId", async () => {+ const trace = [+ {+ domain: "routing_form",+ step: "attribute-logic-evaluated",+ timestamp: Date.now(),+ data: { routeIsFallback: false },+ },+ ];++ vi.mocked(mockPrisma.pendingRoutingTrace.create).mockResolvedValue({+ id: "pending-1",+ createdAt: new Date(),+ trace,+ formResponseId: 123,+ queuedFormResponseId: null,+ });++ await repository.create({+ trace,+ formResponseId: 123,+ });++ expect(mockPrisma.pendingRoutingTrace.create).toHaveBeenCalledWith({+ data: {+ createdAt: expect.any(Date),+ trace,+ formResponseId: 123,+ queuedFormResponseId: undefined,+ },+ });+ });++ it("should create a pending routing trace with queuedFormResponseId", async () => {+ const trace = [+ {+ domain: "routing_form",+ step: "attribute-logic-evaluated",+ timestamp: Date.now(),+ data: { routeIsFallback: true },+ },+ ];++ vi.mocked(mockPrisma.pendingRoutingTrace.create).mockResolvedValue({+ id: "pending-2",+ createdAt: new Date(),+ trace,+ formResponseId: null,+ queuedFormResponseId: "queued-123",+ });++ await repository.create({+ trace,+ queuedFormResponseId: "queued-123",+ });++ expect(mockPrisma.pendingRoutingTrace.create).toHaveBeenCalledWith({+ data: {+ createdAt: expect.any(Date),+ trace,+ formResponseId: undefined,+ queuedFormResponseId: "queued-123",+ },+ });+ });++ it("should create a pending routing trace with empty trace array", async () => {+ const trace: never[] = [];++ vi.mocked(mockPrisma.pendingRoutingTrace.create).mockResolvedValue({+ id: "pending-3",+ createdAt: new Date(),+ trace,+ formResponseId: 456,+ queuedFormResponseId: null,+ });++ await repository.create({+ trace,+ formResponseId: 456,+ });++ expect(mockPrisma.pendingRoutingTrace.create).toHaveBeenCalledWith({+ data: {+ createdAt: expect.any(Date),+ trace,+ formResponseId: 456,+ queuedFormResponseId: undefined,+ },+ });+ });+ });++ describe("findByFormResponseId", () => {+ it("should find a pending routing trace by formResponseId", async () => {+ const trace = [+ {+ domain: "routing_form",+ step: "attribute-logic-evaluated",+ timestamp: Date.now(),+ data: { routeIsFallback: false },+ },+ ];++ const mockResult = {+ id: "pending-1",+ createdAt: new Date("2025-01-01T10:00:00Z"),+ trace,+ formResponseId: 123,+ queuedFormResponseId: null,+ };++ vi.mocked(mockPrisma.pendingRoutingTrace.findUnique).mockResolvedValue(mockResult);++ const result = await repository.findByFormResponseId(123);++ expect(mockPrisma.pendingRoutingTrace.findUnique).toHaveBeenCalledWith({+ where: { formResponseId: 123 },+ });+ expect(result).toEqual({+ id: "pending-1",+ createdAt: new Date("2025-01-01T10:00:00Z"),+ trace,+ formResponseId: 123,+ queuedFormResponseId: null,+ });+ });++ it("should return null when no pending routing trace is found", async () => {+ vi.mocked(mockPrisma.pendingRoutingTrace.findUnique).mockResolvedValue(null);++ const result = await repository.findByFormResponseId(999);++ expect(mockPrisma.pendingRoutingTrace.findUnique).toHaveBeenCalledWith({+ where: { formResponseId: 999 },+ });+ expect(result).toBeNull();+ });+ });++ describe("findByQueuedFormResponseId", () => {+ it("should find a pending routing trace by queuedFormResponseId", async () => {+ const trace = [+ {+ domain: "salesforce",+ step: "salesforce_assignment",+ timestamp: Date.now(),+ data: { email: "[email protected]" },+ },+ ];++ const mockResult = {+ id: "pending-2",+ createdAt: new Date("2025-01-02T10:00:00Z"),+ trace,+ formResponseId: null,+ queuedFormResponseId: "queued-456",+ };++ vi.mocked(mockPrisma.pendingRoutingTrace.findUnique).mockResolvedValue(mockResult);++ const result = await repository.findByQueuedFormResponseId("queued-456");++ expect(mockPrisma.pendingRoutingTrace.findUnique).toHaveBeenCalledWith({+ where: { queuedFormResponseId: "queued-456" },+ });+ expect(result).toEqual({+ id: "pending-2",+ createdAt: new Date("2025-01-02T10:00:00Z"),+ trace,+ formResponseId: null,+ queuedFormResponseId: "queued-456",+ });+ });++ it("should return null when no pending routing trace is found by queuedFormResponseId", async () => {+ vi.mocked(mockPrisma.pendingRoutingTrace.findUnique).mockResolvedValue(null);++ const result = await repository.findByQueuedFormResponseId("non-existent");++ expect(mockPrisma.pendingRoutingTrace.findUnique).toHaveBeenCalledWith({+ where: { queuedFormResponseId: "non-existent" },+ });+ expect(result).toBeNull();+ });+ });+});diff --git a/packages/features/routing-trace/repositories/PrismaPendingRoutingTraceRepository.ts b/packages/features/routing-trace/repositories/PrismaPendingRoutingTraceRepository.tsnew file mode 100644index 00000000000..d1850e0e3bc--- /dev/null+++ b/packages/features/routing-trace/repositories/PrismaPendingRoutingTraceRepository.ts@@ -0,0 +1,64 @@+import type { PrismaClient } from "@calcom/prisma";+import type { Prisma } from "@calcom/prisma/client";++import type { RoutingTrace } from "./RoutingTraceRepository.interface";+import type {+ IPendingRoutingTraceRepository,+ IPendingRoutingTraceRepositoryCreateArgs,+ PendingRoutingTraceRecord,+} from "./PendingRoutingTraceRepository.interface";++export class PrismaPendingRoutingTraceRepository+ implements IPendingRoutingTraceRepository+{+ constructor(private readonly prisma: PrismaClient) {}++ async create(args: IPendingRoutingTraceRepositoryCreateArgs): Promise<void> {+ await this.prisma.pendingRoutingTrace.create({+ data: {+ createdAt: new Date(),+ trace: args.trace as Prisma.InputJsonValue,+ formResponseId:+ "formResponseId" in args ? args.formResponseId : undefined,+ queuedFormResponseId:+ "queuedFormResponseId" in args+ ? args.queuedFormResponseId+ : undefined,+ },+ });+ }++ async findByFormResponseId(formResponseId: number): Promise<PendingRoutingTraceRecord | null> {+ const result = await this.prisma.pendingRoutingTrace.findUnique({+ where: { formResponseId },+ });+ if (!result) return null;+ return {+ ...result,+ trace: result.trace as RoutingTrace,+ };+ }++ async findByQueuedFormResponseId(+ queuedFormResponseId: string+ ): Promise<PendingRoutingTraceRecord | null> {+ const result = await this.prisma.pendingRoutingTrace.findUnique({+ where: { queuedFormResponseId },+ });+ if (!result) return null;+ return {+ ...result,+ trace: result.trace as RoutingTrace,+ };+ }++ async linkToFormResponse(args: {+ queuedFormResponseId: string;+ formResponseId: number;+ }): Promise<void> {+ await this.prisma.pendingRoutingTrace.update({+ where: { queuedFormResponseId: args.queuedFormResponseId },+ data: { formResponseId: args.formResponseId },+ });+ }+}diff --git a/packages/features/routing-trace/repositories/PrismaRoutingTraceRepository.test.ts b/packages/features/routing-trace/repositories/PrismaRoutingTraceRepository.test.tsnew file mode 100644index 00000000000..0bdfd258caf--- /dev/null+++ b/packages/features/routing-trace/repositories/PrismaRoutingTraceRepository.test.ts@@ -0,0 +1,252 @@+import type { PrismaClient } from "@calcom/prisma";+import { beforeEach, describe, expect, it, vi } from "vitest";++import { PrismaRoutingTraceRepository } from "./PrismaRoutingTraceRepository";++describe("PrismaRoutingTraceRepository", () => {+ let repository: PrismaRoutingTraceRepository;++ const mockPrisma = {+ routingTrace: {+ create: vi.fn(),+ },+ } as unknown as PrismaClient;++ beforeEach(() => {+ vi.clearAllMocks();+ repository = new PrismaRoutingTraceRepository(mockPrisma);+ });++ describe("create", () => {+ it("should create a routing trace with all fields", async () => {+ const trace = [+ {+ domain: "routing_form",+ step: "attribute-logic-evaluated",+ timestamp: Date.now(),+ data: { routeIsFallback: false },+ },+ ];++ const mockResult = {+ id: "trace-1",+ createdAt: new Date("2025-01-01T10:00:00Z"),+ trace,+ formResponseId: 123,+ queuedFormResponseId: null,+ bookingUid: "booking-uid-123",+ assignmentReasonId: 42,+ };++ vi.mocked(mockPrisma.routingTrace.create).mockResolvedValue(mockResult);++ const result = await repository.create({+ trace,+ formResponseId: 123,+ bookingUid: "booking-uid-123",+ assignmentReasonId: 42,+ });++ expect(mockPrisma.routingTrace.create).toHaveBeenCalledWith({+ data: {+ createdAt: expect.any(Date),+ trace,+ formResponseId: 123,+ queuedFormResponseId: undefined,+ bookingUid: "booking-uid-123",+ assignmentReasonId: 42,+ },+ });+ expect(result).toEqual({+ id: "trace-1",+ createdAt: new Date("2025-01-01T10:00:00Z"),+ trace,+ formResponseId: 123,+ queuedFormResponseId: null,+ bookingUid: "booking-uid-123",+ assignmentReasonId: 42,+ });+ });++ it("should create a routing trace with queuedFormResponseId", async () => {+ const trace = [+ {+ domain: "salesforce",+ step: "salesforce_assignment",+ timestamp: Date.now(),+ data: { email: "[email protected]" },+ },+ ];++ const mockResult = {+ id: "trace-2",+ createdAt: new Date("2025-01-02T10:00:00Z"),+ trace,+ formResponseId: null,+ queuedFormResponseId: "queued-456",+ bookingUid: "booking-uid-456",+ assignmentReasonId: 100,+ };++ vi.mocked(mockPrisma.routingTrace.create).mockResolvedValue(mockResult);++ const result = await repository.create({+ trace,+ queuedFormResponseId: "queued-456",+ bookingUid: "booking-uid-456",+ assignmentReasonId: 100,+ });++ expect(mockPrisma.routingTrace.create).toHaveBeenCalledWith({+ data: {+ createdAt: expect.any(Date),+ trace,+ formResponseId: undefined,+ queuedFormResponseId: "queued-456",+ bookingUid: "booking-uid-456",+ assignmentReasonId: 100,+ },+ });+ expect(result).toEqual({+ id: "trace-2",+ createdAt: new Date("2025-01-02T10:00:00Z"),+ trace,+ formResponseId: null,+ queuedFormResponseId: "queued-456",+ bookingUid: "booking-uid-456",+ assignmentReasonId: 100,+ });+ });++ it("should create a routing trace without assignmentReasonId", async () => {+ const trace = [+ {+ domain: "other_domain",+ step: "some_step",+ timestamp: Date.now(),+ data: {},+ },+ ];++ const mockResult = {+ id: "trace-3",+ createdAt: new Date("2025-01-03T10:00:00Z"),+ trace,+ formResponseId: 789,+ queuedFormResponseId: null,+ bookingUid: "booking-uid-789",+ assignmentReasonId: null,+ };++ vi.mocked(mockPrisma.routingTrace.create).mockResolvedValue(mockResult);++ const result = await repository.create({+ trace,+ formResponseId: 789,+ bookingUid: "booking-uid-789",+ });++ expect(mockPrisma.routingTrace.create).toHaveBeenCalledWith({+ data: {+ createdAt: expect.any(Date),+ trace,+ formResponseId: 789,+ queuedFormResponseId: undefined,+ bookingUid: "booking-uid-789",+ assignmentReasonId: undefined,+ },+ });+ expect(result).toEqual({+ id: "trace-3",+ createdAt: new Date("2025-01-03T10:00:00Z"),+ trace,+ formResponseId: 789,+ queuedFormResponseId: null,+ bookingUid: "booking-uid-789",+ assignmentReasonId: null,+ });+ });++ it("should create a routing trace with multiple trace steps", async () => {+ const trace = [+ {+ domain: "salesforce",+ step: "salesforce_assignment",+ timestamp: Date.now() - 1000,+ data: { email: "[email protected]", recordType: "Contact", recordId: "003ABC" },+ },+ {+ domain: "routing_form",+ step: "attribute-logic-evaluated",+ timestamp: Date.now(),+ data: { routeIsFallback: false },+ },+ ];++ const mockResult = {+ id: "trace-4",+ createdAt: new Date("2025-01-04T10:00:00Z"),+ trace,+ formResponseId: 111,+ queuedFormResponseId: null,+ bookingUid: "booking-uid-111",+ assignmentReasonId: 50,+ };++ vi.mocked(mockPrisma.routingTrace.create).mockResolvedValue(mockResult);++ const result = await repository.create({+ trace,+ formResponseId: 111,+ bookingUid: "booking-uid-111",+ assignmentReasonId: 50,+ });++ expect(mockPrisma.routingTrace.create).toHaveBeenCalledWith({+ data: {+ createdAt: expect.any(Date),+ trace,+ formResponseId: 111,+ queuedFormResponseId: undefined,+ bookingUid: "booking-uid-111",+ assignmentReasonId: 50,+ },+ });+ expect(result.trace).toHaveLength(2);+ });++ it("should create a routing trace with empty trace array", async () => {+ const trace: never[] = [];++ const mockResult = {+ id: "trace-5",+ createdAt: new Date("2025-01-05T10:00:00Z"),+ trace,+ formResponseId: 222,+ queuedFormResponseId: null,+ bookingUid: "booking-uid-222",+ assignmentReasonId: null,+ };++ vi.mocked(mockPrisma.routingTrace.create).mockResolvedValue(mockResult);++ const result = await repository.create({+ trace,+ formResponseId: 222,+ bookingUid: "booking-uid-222",+ });++ expect(mockPrisma.routingTrace.create).toHaveBeenCalledWith({+ data: {+ createdAt: expect.any(Date),+ trace,+ formResponseId: 222,+ queuedFormResponseId: undefined,+ bookingUid: "booking-uid-222",+ assignmentReasonId: undefined,+ },+ });+ expect(result.trace).toEqual([]);+ });+ });+});diff --git a/packages/features/routing-trace/repositories/PrismaRoutingTraceRepository.ts b/packages/features/routing-trace/repositories/PrismaRoutingTraceRepository.tsnew file mode 100644index 00000000000..ed910763bfc--- /dev/null+++ b/packages/features/routing-trace/repositories/PrismaRoutingTraceRepository.ts@@ -0,0 +1,30 @@+import type { PrismaClient } from "@calcom/prisma";+import type { Prisma } from "@calcom/prisma/client";++import type {+ IRoutingTraceRepository,+ IRoutingTraceRepositoryCreateArgs,+ RoutingTrace,+ RoutingTraceRecord,+} from "./RoutingTraceRepository.interface";++export class PrismaRoutingTraceRepository implements IRoutingTraceRepository {+ constructor(private readonly prisma: PrismaClient) {}++ async create(args: IRoutingTraceRepositoryCreateArgs): Promise<RoutingTraceRecord> {+ const result = await this.prisma.routingTrace.create({+ data: {+ createdAt: new Date(),+ trace: args.trace as Prisma.InputJsonValue,+ formResponseId: args.formResponseId,+ queuedFormResponseId: args.queuedFormResponseId,+ bookingUid: args.bookingUid,+ assignmentReasonId: args.assignmentReasonId,+ },+ });+ return {+ ...result,+ trace: result.trace as RoutingTrace,+ };+ }+}diff --git a/packages/features/routing-trace/repositories/RoutingTraceRepository.interface.ts b/packages/features/routing-trace/repositories/RoutingTraceRepository.interface.tsnew file mode 100644index 00000000000..34b9042ae50--- /dev/null+++ b/packages/features/routing-trace/repositories/RoutingTraceRepository.interface.ts@@ -0,0 +1,38 @@+import z from "zod";+import type { routingStepSchema } from "../schema/zod";++export type RoutingStep = z.infer<typeof routingStepSchema>;++export type RoutingTrace = RoutingStep[];++export interface BaseRoutingTrace {+ id: string;+ createdAt: Date;+ trace: string;+}++export interface RoutingTraceWithFormResponse extends BaseRoutingTrace {+ formResponseId: string;+}++export interface RoutingTraceRecord {+ id: string;+ createdAt: Date;+ trace: RoutingTrace;+ formResponseId: number | null;+ queuedFormResponseId: string | null;+ bookingUid: string | null;+ assignmentReasonId: number | null;+}++export interface IRoutingTraceRepositoryCreateArgs {+ trace: RoutingTrace;+ formResponseId?: number;+ queuedFormResponseId?: string;+ bookingUid: string;+ assignmentReasonId?: number;+}++export interface IRoutingTraceRepository {+ create(args: IRoutingTraceRepositoryCreateArgs): Promise<RoutingTraceRecord>;+}diff --git a/packages/features/routing-trace/schema/zod.ts b/packages/features/routing-trace/schema/zod.tsnew file mode 100644index 00000000000..ab36789fb89--- /dev/null+++ b/packages/features/routing-trace/schema/zod.ts@@ -0,0 +1,8 @@+import z from "zod";++export const routingStepSchema = z.object({+ domain: z.string(),+ step: z.string(),+ timestamp: z.number(),+ data: z.record(z.unknown()),+});diff --git a/packages/features/routing-trace/services/RoutingTraceService.test.ts b/packages/features/routing-trace/services/RoutingTraceService.test.tsnew file mode 100644index 00000000000..3f2b522feac--- /dev/null+++ b/packages/features/routing-trace/services/RoutingTraceService.test.ts@@ -0,0 +1,663 @@+import type { AssignmentReasonRepository } from "@calcom/features/assignment-reason/repositories/AssignmentReasonRepository";+import { AssignmentReasonEnum } from "@calcom/prisma/enums";+import { beforeEach, describe, expect, it, vi } from "vitest";++import type {+ IPendingRoutingTraceRepository,+ PendingRoutingTraceRecord,+} from "../repositories/PendingRoutingTraceRepository.interface";+import type { IRoutingTraceRepository } from "../repositories/RoutingTraceRepository.interface";+import { RoutingTraceService } from "./RoutingTraceService";++describe("RoutingTraceService", () => {+ let service: RoutingTraceService;+ let mockPendingRoutingTraceRepository: IPendingRoutingTraceRepository;+ let mockRoutingTraceRepository: IRoutingTraceRepository;+ let mockAssignmentReasonRepository: Pick<AssignmentReasonRepository, "createAssignmentReason">;++ function createMockPendingRoutingTraceRepository(): IPendingRoutingTraceRepository {+ return {+ create: vi.fn(),+ findByFormResponseId: vi.fn(),+ findByQueuedFormResponseId: vi.fn(),+ };+ }++ function createMockRoutingTraceRepository(): IRoutingTraceRepository {+ return {+ create: vi.fn(),+ };+ }++ function createMockAssignmentReasonRepository(): Pick<AssignmentReasonRepository, "createAssignmentReason"> {+ return {+ createAssignmentReason: vi.fn(),+ };+ }++ beforeEach(() => {+ vi.clearAllMocks();+ mockPendingRoutingTraceRepository = createMockPendingRoutingTraceRepository();+ mockRoutingTraceRepository = createMockRoutingTraceRepository();+ mockAssignmentReasonRepository = createMockAssignmentReasonRepository();+ service = new RoutingTraceService({+ pendingRoutingTraceRepository: mockPendingRoutingTraceRepository,+ routingTraceRepository: mockRoutingTraceRepository,+ assignmentReasonRepository: mockAssignmentReasonRepository as AssignmentReasonRepository,+ });+ });++ describe("addStep", () => {+ it("should add a step to the routing trace", () => {+ service.addStep({+ domain: "routing_form",+ step: "attribute-logic-evaluated",+ data: { routeIsFallback: false },+ });++ expect(service.getStepsCount()).toBe(1);+ });++ it("should add multiple steps to the routing trace", () => {+ service.addStep({+ domain: "routing_form",+ step: "attribute-logic-evaluated",+ data: { routeIsFallback: false },+ });++ service.addStep({+ domain: "salesforce",+ step: "salesforce_assignment",+ data: { email: "[email protected]" },+ });++ expect(service.getStepsCount()).toBe(2);+ });++ it("should add step with empty data by default", () => {+ service.addStep({+ domain: "test_domain",+ step: "test_step",+ });++ expect(service.getStepsCount()).toBe(1);+ });+ });++ describe("getStepsCount", () => {+ it("should return 0 when no steps have been added", () => {+ expect(service.getStepsCount()).toBe(0);+ });++ it("should return correct count after adding steps", () => {+ service.addStep({ domain: "test", step: "step1" });+ service.addStep({ domain: "test", step: "step2" });+ service.addStep({ domain: "test", step: "step3" });++ expect(service.getStepsCount()).toBe(3);+ });+ });++ describe("savePendingRoutingTrace", () => {+ it("should save pending trace with formResponseId", async () => {+ service.addStep({+ domain: "routing_form",+ step: "attribute-logic-evaluated",+ data: { routeIsFallback: false },+ });++ await service.savePendingRoutingTrace({ formResponseId: 123 });++ expect(mockPendingRoutingTraceRepository.create).toHaveBeenCalledWith({+ trace: expect.arrayContaining([+ expect.objectContaining({+ domain: "routing_form",+ step: "attribute-logic-evaluated",+ data: { routeIsFallback: false },+ }),+ ]),+ formResponseId: 123,+ });+ });++ it("should save pending trace with queuedFormResponseId", async () => {+ service.addStep({+ domain: "routing_form",+ step: "attribute-logic-evaluated",+ data: { routeIsFallback: true },+ });++ await service.savePendingRoutingTrace({ queuedFormResponseId: "queued-123" });++ expect(mockPendingRoutingTraceRepository.create).toHaveBeenCalledWith({+ trace: expect.arrayContaining([+ expect.objectContaining({+ domain: "routing_form",+ step: "attribute-logic-evaluated",+ data: { routeIsFallback: true },+ }),+ ]),+ queuedFormResponseId: "queued-123",+ });+ });+ });++ describe("processForBooking", () => {+ const baseProcessArgs = {+ bookingId: 1,+ bookingUid: "booking-uid-123",+ organizerEmail: "[email protected]",+ isRerouting: false,+ };++ it("should return null if no pending trace is found", async () => {+ vi.mocked(mockPendingRoutingTraceRepository.findByFormResponseId).mockResolvedValue(null);++ const result = await service.processForBooking({+ ...baseProcessArgs,+ formResponseId: 123,+ });++ expect(result).toBeNull();+ });++ it("should return null if no pending trace is found for queuedFormResponseId", async () => {+ vi.mocked(mockPendingRoutingTraceRepository.findByQueuedFormResponseId).mockResolvedValue(null);++ const result = await service.processForBooking({+ ...baseProcessArgs,+ queuedFormResponseId: "queued-123",+ });++ expect(result).toBeNull();+ });++ describe("routing form assignment", () => {+ it("should extract ROUTING_FORM_ROUTING assignment reason", async () => {+ const pendingTrace: PendingRoutingTraceRecord = {+ id: "pending-1",+ createdAt: new Date(),+ trace: [+ {+ domain: "routing_form",+ step: "attribute-logic-evaluated",+ timestamp: Date.now(),+ data: { routeIsFallback: false },+ },+ ],+ formResponseId: 123,+ queuedFormResponseId: null,+ };++ vi.mocked(mockPendingRoutingTraceRepository.findByFormResponseId).mockResolvedValue(pendingTrace);+ vi.mocked(mockAssignmentReasonRepository.createAssignmentReason).mockResolvedValue({+ id: 1,+ bookingId: 1,+ reasonEnum: AssignmentReasonEnum.ROUTING_FORM_ROUTING,+ reasonString: "",+ });+ vi.mocked(mockRoutingTraceRepository.create).mockResolvedValue({+ id: "trace-1",+ createdAt: new Date(),+ trace: pendingTrace.trace,+ formResponseId: 123,+ queuedFormResponseId: null,+ bookingUid: "booking-uid-123",+ assignmentReasonId: 1,+ });++ const result = await service.processForBooking({+ ...baseProcessArgs,+ formResponseId: 123,+ });++ expect(result).toEqual({+ assignmentReason: {+ reasonEnum: AssignmentReasonEnum.ROUTING_FORM_ROUTING,+ reasonString: "",+ },+ });+ expect(mockAssignmentReasonRepository.createAssignmentReason).toHaveBeenCalledWith({+ bookingId: 1,+ reasonEnum: AssignmentReasonEnum.ROUTING_FORM_ROUTING,+ reasonString: "",+ });+ });++ it("should extract ROUTING_FORM_ROUTING_FALLBACK assignment reason when routeIsFallback is true", async () => {+ const pendingTrace: PendingRoutingTraceRecord = {+ id: "pending-1",+ createdAt: new Date(),+ trace: [+ {+ domain: "routing_form",+ step: "attribute-logic-evaluated",+ timestamp: Date.now(),+ data: { routeIsFallback: true },+ },+ ],+ formResponseId: 123,+ queuedFormResponseId: null,+ };++ vi.mocked(mockPendingRoutingTraceRepository.findByFormResponseId).mockResolvedValue(pendingTrace);+ vi.mocked(mockAssignmentReasonRepository.createAssignmentReason).mockResolvedValue({+ id: 1,+ bookingId: 1,+ reasonEnum: AssignmentReasonEnum.ROUTING_FORM_ROUTING_FALLBACK,+ reasonString: "",+ });+ vi.mocked(mockRoutingTraceRepository.create).mockResolvedValue({+ id: "trace-1",+ createdAt: new Date(),+ trace: pendingTrace.trace,+ formResponseId: 123,+ queuedFormResponseId: null,+ bookingUid: "booking-uid-123",+ assignmentReasonId: 1,+ });++ const result = await service.processForBooking({+ ...baseProcessArgs,+ formResponseId: 123,+ });++ expect(result).toEqual({+ assignmentReason: {+ reasonEnum: AssignmentReasonEnum.ROUTING_FORM_ROUTING_FALLBACK,+ reasonString: "",+ },+ });+ });++ it("should extract REROUTED assignment reason when isRerouting is true", async () => {+ const pendingTrace: PendingRoutingTraceRecord = {+ id: "pending-1",+ createdAt: new Date(),+ trace: [+ {+ domain: "routing_form",+ step: "attribute-logic-evaluated",+ timestamp: Date.now(),+ data: { routeIsFallback: false },+ },+ ],+ formResponseId: 123,+ queuedFormResponseId: null,+ };++ vi.mocked(mockPendingRoutingTraceRepository.findByFormResponseId).mockResolvedValue(pendingTrace);+ vi.mocked(mockAssignmentReasonRepository.createAssignmentReason).mockResolvedValue({+ id: 1,+ bookingId: 1,+ reasonEnum: AssignmentReasonEnum.REROUTED,+ reasonString: "Rerouted by [email protected]",+ });+ vi.mocked(mockRoutingTraceRepository.create).mockResolvedValue({+ id: "trace-1",+ createdAt: new Date(),+ trace: pendingTrace.trace,+ formResponseId: 123,+ queuedFormResponseId: null,+ bookingUid: "booking-uid-123",+ assignmentReasonId: 1,+ });++ const result = await service.processForBooking({+ ...baseProcessArgs,+ formResponseId: 123,+ isRerouting: true,+ reroutedByEmail: "[email protected]",+ });++ expect(result).toEqual({+ assignmentReason: {+ reasonEnum: AssignmentReasonEnum.REROUTED,+ reasonString: "Rerouted by [email protected]",+ },+ });+ });+ });++ describe("salesforce assignment", () => {+ it("should extract SALESFORCE_ASSIGNMENT when organizer matches CRM contact owner", async () => {+ const pendingTrace: PendingRoutingTraceRecord = {+ id: "pending-1",+ createdAt: new Date(),+ trace: [+ {+ domain: "salesforce",+ step: "salesforce_assignment",+ timestamp: Date.now(),+ data: {+ email: "[email protected]",+ recordType: "Contact",+ recordId: "003ABC123",+ },+ },+ ],+ formResponseId: 123,+ queuedFormResponseId: null,+ };++ vi.mocked(mockPendingRoutingTraceRepository.findByFormResponseId).mockResolvedValue(pendingTrace);+ vi.mocked(mockAssignmentReasonRepository.createAssignmentReason).mockResolvedValue({+ id: 1,+ bookingId: 1,+ reasonEnum: AssignmentReasonEnum.SALESFORCE_ASSIGNMENT,+ reasonString: "Salesforce contact owner: [email protected] (Contact ID: 003ABC123)",+ });+ vi.mocked(mockRoutingTraceRepository.create).mockResolvedValue({+ id: "trace-1",+ createdAt: new Date(),+ trace: pendingTrace.trace,+ formResponseId: 123,+ queuedFormResponseId: null,+ bookingUid: "booking-uid-123",+ assignmentReasonId: 1,+ });++ const result = await service.processForBooking({+ ...baseProcessArgs,+ formResponseId: 123,+ });++ expect(result).toEqual({+ assignmentReason: {+ reasonEnum: AssignmentReasonEnum.SALESFORCE_ASSIGNMENT,+ reasonString: "Salesforce contact owner: [email protected] (Contact ID: 003ABC123)",+ },+ });+ });++ it("should use account lookup field reason string when rrSkipToAccountLookupField is true", async () => {+ const pendingTrace: PendingRoutingTraceRecord = {+ id: "pending-1",+ createdAt: new Date(),+ trace: [+ {+ domain: "salesforce",+ step: "salesforce_assignment",+ timestamp: Date.now(),+ data: {+ email: "[email protected]",+ recordType: "Account",+ recordId: "001ABC123",+ rrSkipToAccountLookupField: true,+ rrSKipToAccountLookupFieldName: "Account_Owner__c",+ },+ },+ ],+ formResponseId: 123,+ queuedFormResponseId: null,+ };++ vi.mocked(mockPendingRoutingTraceRepository.findByFormResponseId).mockResolvedValue(pendingTrace);+ vi.mocked(mockAssignmentReasonRepository.createAssignmentReason).mockResolvedValue({+ id: 1,+ bookingId: 1,+ reasonEnum: AssignmentReasonEnum.SALESFORCE_ASSIGNMENT,+ reasonString:+ "Salesforce account lookup field: Account_Owner__c - [email protected] (Account ID: 001ABC123)",+ });+ vi.mocked(mockRoutingTraceRepository.create).mockResolvedValue({+ id: "trace-1",+ createdAt: new Date(),+ trace: pendingTrace.trace,+ formResponseId: 123,+ queuedFormResponseId: null,+ bookingUid: "booking-uid-123",+ assignmentReasonId: 1,+ });++ const result = await service.processForBooking({+ ...baseProcessArgs,+ formResponseId: 123,+ });++ expect(result).toEqual({+ assignmentReason: {+ reasonEnum: AssignmentReasonEnum.SALESFORCE_ASSIGNMENT,+ reasonString:+ "Salesforce account lookup field: Account_Owner__c - [email protected] (Account ID: 001ABC123)",+ },+ });+ });++ it("should fall back to routing form assignment when organizer does not match CRM contact owner", async () => {+ const pendingTrace: PendingRoutingTraceRecord = {+ id: "pending-1",+ createdAt: new Date(),+ trace: [+ {+ domain: "salesforce",+ step: "salesforce_assignment",+ timestamp: Date.now(),+ data: {+ email: "[email protected]",+ recordType: "Contact",+ recordId: "003ABC123",+ },+ },+ {+ domain: "routing_form",+ step: "attribute-logic-evaluated",+ timestamp: Date.now(),+ data: { routeIsFallback: false },+ },+ ],+ formResponseId: 123,+ queuedFormResponseId: null,+ };++ vi.mocked(mockPendingRoutingTraceRepository.findByFormResponseId).mockResolvedValue(pendingTrace);+ vi.mocked(mockAssignmentReasonRepository.createAssignmentReason).mockResolvedValue({+ id: 1,+ bookingId: 1,+ reasonEnum: AssignmentReasonEnum.ROUTING_FORM_ROUTING,+ reasonString: "",+ });+ vi.mocked(mockRoutingTraceRepository.create).mockResolvedValue({+ id: "trace-1",+ createdAt: new Date(),+ trace: pendingTrace.trace,+ formResponseId: 123,+ queuedFormResponseId: null,+ bookingUid: "booking-uid-123",+ assignmentReasonId: 1,+ });++ const result = await service.processForBooking({+ ...baseProcessArgs,+ formResponseId: 123,+ });++ expect(result).toEqual({+ assignmentReason: {+ reasonEnum: AssignmentReasonEnum.ROUTING_FORM_ROUTING,+ reasonString: "",+ },+ });+ });++ it("should handle case-insensitive email matching for CRM assignment", async () => {+ const pendingTrace: PendingRoutingTraceRecord = {+ id: "pending-1",+ createdAt: new Date(),+ trace: [+ {+ domain: "salesforce",+ step: "salesforce_assignment",+ timestamp: Date.now(),+ data: {+ email: "[email protected]",+ recordType: "Contact",+ recordId: "003ABC123",+ },+ },+ ],+ formResponseId: 123,+ queuedFormResponseId: null,+ };++ vi.mocked(mockPendingRoutingTraceRepository.findByFormResponseId).mockResolvedValue(pendingTrace);+ vi.mocked(mockAssignmentReasonRepository.createAssignmentReason).mockResolvedValue({+ id: 1,+ bookingId: 1,+ reasonEnum: AssignmentReasonEnum.SALESFORCE_ASSIGNMENT,+ reasonString: "Salesforce contact owner: [email protected] (Contact ID: 003ABC123)",+ });+ vi.mocked(mockRoutingTraceRepository.create).mockResolvedValue({+ id: "trace-1",+ createdAt: new Date(),+ trace: pendingTrace.trace,+ formResponseId: 123,+ queuedFormResponseId: null,+ bookingUid: "booking-uid-123",+ assignmentReasonId: 1,+ });++ const result = await service.processForBooking({+ ...baseProcessArgs,+ formResponseId: 123,+ });++ expect(result?.assignmentReason?.reasonEnum).toBe(AssignmentReasonEnum.SALESFORCE_ASSIGNMENT);+ });+ });++ it("should create permanent routing trace with assignment reason", async () => {+ const pendingTrace: PendingRoutingTraceRecord = {+ id: "pending-1",+ createdAt: new Date(),+ trace: [+ {+ domain: "routing_form",+ step: "attribute-logic-evaluated",+ timestamp: Date.now(),+ data: { routeIsFallback: false },+ },+ ],+ formResponseId: 123,+ queuedFormResponseId: null,+ };++ vi.mocked(mockPendingRoutingTraceRepository.findByFormResponseId).mockResolvedValue(pendingTrace);+ vi.mocked(mockAssignmentReasonRepository.createAssignmentReason).mockResolvedValue({+ id: 42,+ bookingId: 1,+ reasonEnum: AssignmentReasonEnum.ROUTING_FORM_ROUTING,+ reasonString: "",+ });+ vi.mocked(mockRoutingTraceRepository.create).mockResolvedValue({+ id: "trace-1",+ createdAt: new Date(),+ trace: pendingTrace.trace,+ formResponseId: 123,+ queuedFormResponseId: null,+ bookingUid: "booking-uid-123",+ assignmentReasonId: 42,+ });++ await service.processForBooking({+ ...baseProcessArgs,+ formResponseId: 123,+ });++ expect(mockRoutingTraceRepository.create).toHaveBeenCalledWith({+ trace: pendingTrace.trace,+ formResponseId: 123,+ queuedFormResponseId: undefined,+ bookingUid: "booking-uid-123",+ assignmentReasonId: 42,+ });+ });++ it("should handle pending trace without assignment reason data", async () => {+ const pendingTrace: PendingRoutingTraceRecord = {+ id: "pending-1",+ createdAt: new Date(),+ trace: [+ {+ domain: "other_domain",+ step: "some_step",+ timestamp: Date.now(),+ data: {},+ },+ ],+ formResponseId: 123,+ queuedFormResponseId: null,+ };++ vi.mocked(mockPendingRoutingTraceRepository.findByFormResponseId).mockResolvedValue(pendingTrace);+ vi.mocked(mockRoutingTraceRepository.create).mockResolvedValue({+ id: "trace-1",+ createdAt: new Date(),+ trace: pendingTrace.trace,+ formResponseId: 123,+ queuedFormResponseId: null,+ bookingUid: "booking-uid-123",+ assignmentReasonId: null,+ });++ const result = await service.processForBooking({+ ...baseProcessArgs,+ formResponseId: 123,+ });++ expect(result).toEqual({+ assignmentReason: undefined,+ });+ expect(mockAssignmentReasonRepository.createAssignmentReason).not.toHaveBeenCalled();+ expect(mockRoutingTraceRepository.create).toHaveBeenCalledWith({+ trace: pendingTrace.trace,+ formResponseId: 123,+ queuedFormResponseId: undefined,+ bookingUid: "booking-uid-123",+ assignmentReasonId: undefined,+ });+ });++ it("should process pending trace found by queuedFormResponseId", async () => {+ const pendingTrace: PendingRoutingTraceRecord = {+ id: "pending-1",+ createdAt: new Date(),+ trace: [+ {+ domain: "routing_form",+ step: "attribute-logic-evaluated",+ timestamp: Date.now(),+ data: { routeIsFallback: false },+ },+ ],+ formResponseId: null,+ queuedFormResponseId: "queued-123",+ };++ vi.mocked(mockPendingRoutingTraceRepository.findByQueuedFormResponseId).mockResolvedValue(pendingTrace);+ vi.mocked(mockAssignmentReasonRepository.createAssignmentReason).mockResolvedValue({+ id: 1,+ bookingId: 1,+ reasonEnum: AssignmentReasonEnum.ROUTING_FORM_ROUTING,+ reasonString: "",+ });+ vi.mocked(mockRoutingTraceRepository.create).mockResolvedValue({+ id: "trace-1",+ createdAt: new Date(),+ trace: pendingTrace.trace,+ formResponseId: null,+ queuedFormResponseId: "queued-123",+ bookingUid: "booking-uid-123",+ assignmentReasonId: 1,+ });++ const result = await service.processForBooking({+ ...baseProcessArgs,+ queuedFormResponseId: "queued-123",+ });++ expect(mockPendingRoutingTraceRepository.findByQueuedFormResponseId).toHaveBeenCalledWith("queued-123");+ expect(result?.assignmentReason?.reasonEnum).toBe(AssignmentReasonEnum.ROUTING_FORM_ROUTING);+ });+ });+});diff --git a/packages/features/routing-trace/services/RoutingTraceService.ts b/packages/features/routing-trace/services/RoutingTraceService.tsnew file mode 100644index 00000000000..b502400cbea--- /dev/null+++ b/packages/features/routing-trace/services/RoutingTraceService.ts@@ -0,0 +1,269 @@+import type { AssignmentReasonRepository } from "@calcom/features/assignment-reason/repositories/AssignmentReasonRepository";+import logger from "@calcom/lib/logger";+import { AssignmentReasonEnum } from "@calcom/prisma/enums";++import type { IPendingRoutingTraceRepository } from "../repositories/PendingRoutingTraceRepository.interface";+import type {+ IRoutingTraceRepository,+ RoutingStep,+ RoutingTrace,+} from "../repositories/RoutingTraceRepository.interface";++export const ROUTING_TRACE_DOMAINS = {+ SALESFORCE: "salesforce",+ ROUTING_FORM: "routing_form",+} as const;++export const ROUTING_TRACE_STEPS = {+ SALESFORCE_ASSIGNMENT: "salesforce_assignment",+ ATTRIBUTE_LOGIC_EVALUATED: "attribute-logic-evaluated",+} as const;++interface IRoutingTraceServiceDeps {+ pendingRoutingTraceRepository: IPendingRoutingTraceRepository;+ routingTraceRepository: IRoutingTraceRepository;+ assignmentReasonRepository: AssignmentReasonRepository;+}++export interface ProcessRoutingTraceResult {+ assignmentReason?: {+ reasonEnum: AssignmentReasonEnum;+ reasonString: string;+ };+}++export class RoutingTraceService {+ private routingTraceSteps: RoutingStep[] = [];++ constructor(private readonly deps: IRoutingTraceServiceDeps) {}++ /** For debugging - get the number of steps recorded */+ getStepsCount(): number {+ return this.routingTraceSteps.length;+ }++ /** To be called by the domain specific routing trace services */+ addStep({+ domain,+ step,+ data = {},+ }: {+ domain: string;+ step: string;+ data?: Record<string, unknown>;+ }) {+ this.routingTraceSteps.push({ domain, step, timestamp: Date.now(), data });+ }++ /** Save pending trace when routing form is submitted (before booking is created) */+ async savePendingRoutingTrace(+ args: { formResponseId: number } | { queuedFormResponseId: string }+ ) {+ await this.deps.pendingRoutingTraceRepository.create({+ trace: this.routingTraceSteps,+ ...args,+ });+ }++ /**+ * Process pending routing trace for a booking.+ * Looks up the pending trace, extracts assignment reason, creates permanent trace.+ */+ async processForBooking(args: {+ formResponseId?: number;+ queuedFormResponseId?: string;+ bookingId: number;+ bookingUid: string;+ organizerEmail: string;+ isRerouting: boolean;+ reroutedByEmail?: string | null;+ }): Promise<ProcessRoutingTraceResult | null> {+ const { formResponseId, queuedFormResponseId, bookingId, bookingUid, organizerEmail, isRerouting, reroutedByEmail } = args;++ // 1. Look up pending trace by formResponseId or queuedFormResponseId+ let pendingTrace = null;+ if (formResponseId) {+ pendingTrace = await this.deps.pendingRoutingTraceRepository.findByFormResponseId(formResponseId);+ } else if (queuedFormResponseId) {+ pendingTrace = await this.deps.pendingRoutingTraceRepository.findByQueuedFormResponseId(queuedFormResponseId);+ }++ if (!pendingTrace) {+ logger.warn("Could not find pending routing trace for form response", { formResponseId, queuedFormResponseId, bookingId });+ return null;+ }++ // 2. Extract assignment reason from trace+ const assignmentReasonData = this.extractAssignmentReasonFromTrace(+ pendingTrace.trace,+ {+ organizerEmail,+ isRerouting,+ reroutedByEmail,+ }+ );++ let assignmentReasonId: number | undefined;++ // 3. Create assignment reason record if we have trace-based data+ if (assignmentReasonData) {+ const createdReason = await this.deps.assignmentReasonRepository.createAssignmentReason({+ bookingId,+ reasonEnum: assignmentReasonData.reasonEnum,+ reasonString: assignmentReasonData.reasonString,+ });+ assignmentReasonId = createdReason.id;+ }++ // 4. Create permanent routing trace+ await this.deps.routingTraceRepository.create({+ trace: pendingTrace.trace,+ formResponseId: pendingTrace.formResponseId ?? undefined,+ queuedFormResponseId: pendingTrace.queuedFormResponseId ?? undefined,+ bookingUid,+ assignmentReasonId,+ });++ return {+ assignmentReason: assignmentReasonData+ ? {+ reasonEnum: assignmentReasonData.reasonEnum,+ reasonString: assignmentReasonData.reasonString,+ }+ : undefined,+ };+ }++ /**+ * Extract assignment reason from trace steps.+ * Priority: CRM (Salesforce) > Routing Form+ * CRM assignment is only used if the booking organizer matches the CRM contact owner.+ */+ private extractAssignmentReasonFromTrace(+ trace: RoutingTrace,+ context: {+ organizerEmail: string;+ isRerouting: boolean;+ reroutedByEmail?: string | null;+ }+ ): { reasonEnum: AssignmentReasonEnum; reasonString: string } | null {+ const crmAssignmentStep = trace.find(+ (step) =>+ step.domain === ROUTING_TRACE_DOMAINS.SALESFORCE &&+ step.step === ROUTING_TRACE_STEPS.SALESFORCE_ASSIGNMENT+ );++ if (crmAssignmentStep && crmAssignmentStep.data) {+ const {+ email,+ recordType,+ recordId,+ rrSkipToAccountLookupField,+ rrSKipToAccountLookupFieldName,+ } = crmAssignmentStep.data as {+ email?: string;+ recordType?: string | null;+ recordId?: string;+ rrSkipToAccountLookupField?: boolean;+ rrSKipToAccountLookupFieldName?: string | null;+ };++ // Only use CRM assignment if the booking organizer matches the contact owner+ if (+ email &&+ email.toLowerCase() === context.organizerEmail.toLowerCase()+ ) {+ return {+ reasonEnum: AssignmentReasonEnum.SALESFORCE_ASSIGNMENT,+ reasonString: this.buildSalesforceReasonString({+ email,+ recordType: recordType ?? "Contact", // Default to Contact if not specified+ recordId,+ rrSkipToAccountLookupField,+ rrSKipToAccountLookupFieldName,+ }),+ };+ }+ }++ const routingFormStep = trace.find(+ (step) =>+ step.domain === ROUTING_TRACE_DOMAINS.ROUTING_FORM &&+ step.step === ROUTING_TRACE_STEPS.ATTRIBUTE_LOGIC_EVALUATED+ );++ if (routingFormStep && routingFormStep.data) {+ const { routeIsFallback, attributeRoutingDetails } = routingFormStep.data as {+ routeIsFallback?: boolean;+ attributeRoutingDetails?: Array<{ attributeName: string; attributeValue: string }>;+ };++ const reasonEnum = context.isRerouting+ ? AssignmentReasonEnum.REROUTED+ : routeIsFallback+ ? AssignmentReasonEnum.ROUTING_FORM_ROUTING_FALLBACK+ : AssignmentReasonEnum.ROUTING_FORM_ROUTING;++ return {+ reasonEnum,+ reasonString: this.buildRoutingFormReasonString({+ isRerouting: context.isRerouting,+ reroutedByEmail: context.reroutedByEmail,+ attributeRoutingDetails,+ }),+ };+ }++ logger.warn("Could not extract assignment reason from routing trace - no matching steps found", {+ traceSteps: trace.map((s) => `${s.domain}:${s.step}`),+ });+ return null;+ }++ private buildRoutingFormReasonString(data: {+ isRerouting: boolean;+ reroutedByEmail?: string | null;+ attributeRoutingDetails?: Array<{ attributeName: string; attributeValue: string }>;+ }): string {+ const { isRerouting, reroutedByEmail, attributeRoutingDetails } = data;++ const reroutingPart = isRerouting && reroutedByEmail ? `Rerouted by ${reroutedByEmail}` : "";++ const attributesPart =+ attributeRoutingDetails && attributeRoutingDetails.length > 0+ ? attributeRoutingDetails+ .map(({ attributeName, attributeValue }) => `${attributeName}: ${attributeValue}`)+ .join(", ")+ : "";++ // Combine both parts, matching main branch behavior+ return `${reroutingPart} ${attributesPart}`.trim();+ }++ private buildSalesforceReasonString(data: {+ email: string;+ recordType: string;+ recordId?: string;+ rrSkipToAccountLookupField?: boolean;+ rrSKipToAccountLookupFieldName?: string | null;+ }): string {+ const {+ email,+ recordType,+ recordId,+ rrSkipToAccountLookupField,+ rrSKipToAccountLookupFieldName,+ } = data;++ if (rrSkipToAccountLookupField && rrSKipToAccountLookupFieldName) {+ return `Salesforce account lookup field: ${rrSKipToAccountLookupFieldName} - ${email}${+ recordId ? ` (Account ID: ${recordId})` : ""+ }`;+ }++ const recordLabel = recordType.toLowerCase();+ return `Salesforce ${recordLabel} owner: ${email}${+ recordId ? ` (${recordType} ID: ${recordId})` : ""+ }`;+ }+}diff --git a/packages/prisma/migrations/20260127035022_add_routing_trace_tables/migration.sql b/packages/prisma/migrations/20260127035022_add_routing_trace_tables/migration.sqlnew file mode 100644index 00000000000..bf1eb7b9375--- /dev/null+++ b/packages/prisma/migrations/20260127035022_add_routing_trace_tables/migration.sql@@ -0,0 +1,65 @@+-- CreateTable+CREATE TABLE "public"."PendingRoutingTrace" (+ "id" TEXT NOT NULL,+ "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,+ "trace" JSONB NOT NULL,+ "formResponseId" INTEGER,+ "queuedFormResponseId" TEXT,++ CONSTRAINT "PendingRoutingTrace_pkey" PRIMARY KEY ("id")+);++-- CreateTable+CREATE TABLE "public"."RoutingTrace" (+ "id" TEXT NOT NULL,+ "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,+ "trace" JSONB NOT NULL,+ "formResponseId" INTEGER,+ "queuedFormResponseId" TEXT,+ "bookingUid" TEXT,+ "assignmentReasonId" INTEGER,++ CONSTRAINT "RoutingTrace_pkey" PRIMARY KEY ("id")+);++-- CreateIndex+CREATE UNIQUE INDEX "PendingRoutingTrace_formResponseId_key" ON "public"."PendingRoutingTrace"("formResponseId");++-- CreateIndex+CREATE UNIQUE INDEX "PendingRoutingTrace_queuedFormResponseId_key" ON "public"."PendingRoutingTrace"("queuedFormResponseId");++-- CreateIndex+CREATE UNIQUE INDEX "RoutingTrace_formResponseId_key" ON "public"."RoutingTrace"("formResponseId");++-- CreateIndex+CREATE UNIQUE INDEX "RoutingTrace_queuedFormResponseId_key" ON "public"."RoutingTrace"("queuedFormResponseId");++-- CreateIndex+CREATE UNIQUE INDEX "RoutingTrace_bookingUid_key" ON "public"."RoutingTrace"("bookingUid");++-- CreateIndex+CREATE UNIQUE INDEX "RoutingTrace_assignmentReasonId_key" ON "public"."RoutingTrace"("assignmentReasonId");++-- AddForeignKey+ALTER TABLE "public"."PendingRoutingTrace" ADD CONSTRAINT "PendingRoutingTrace_formResponseId_fkey" FOREIGN KEY ("formResponseId") REFERENCES "public"."App_RoutingForms_FormResponse"("id") ON DELETE CASCADE ON UPDATE CASCADE;++-- AddForeignKey+ALTER TABLE "public"."PendingRoutingTrace" ADD CONSTRAINT "PendingRoutingTrace_queuedFormResponseId_fkey" FOREIGN KEY ("queuedFormResponseId") REFERENCES "public"."App_RoutingForms_QueuedFormResponse"("id") ON DELETE CASCADE ON UPDATE CASCADE;++-- AddForeignKey+ALTER TABLE "public"."RoutingTrace" ADD CONSTRAINT "RoutingTrace_formResponseId_fkey" FOREIGN KEY ("formResponseId") REFERENCES "public"."App_RoutingForms_FormResponse"("id") ON DELETE CASCADE ON UPDATE CASCADE;++-- AddForeignKey+ALTER TABLE "public"."RoutingTrace" ADD CONSTRAINT "RoutingTrace_queuedFormResponseId_fkey" FOREIGN KEY ("queuedFormResponseId") REFERENCES "public"."App_RoutingForms_QueuedFormResponse"("id") ON DELETE CASCADE ON UPDATE CASCADE;++-- AddForeignKey+ALTER TABLE "public"."RoutingTrace" ADD CONSTRAINT "RoutingTrace_bookingUid_fkey" FOREIGN KEY ("bookingUid") REFERENCES "public"."Booking"("uid") ON DELETE CASCADE ON UPDATE CASCADE;++-- AddForeignKey+ALTER TABLE "public"."RoutingTrace" ADD CONSTRAINT "RoutingTrace_assignmentReasonId_fkey" FOREIGN KEY ("assignmentReasonId") REFERENCES "public"."AssignmentReason"("id") ON DELETE CASCADE ON UPDATE CASCADE;++-- AddCheckConstraint: Ensure at least one of formResponseId or queuedFormResponseId is set+ALTER TABLE "public"."PendingRoutingTrace" ADD CONSTRAINT "PendingRoutingTrace_at_least_one_response_id" CHECK ("formResponseId" IS NOT NULL OR "queuedFormResponseId" IS NOT NULL);++-- AddCheckConstraint: Ensure at least one of formResponseId or queuedFormResponseId is set+ALTER TABLE "public"."RoutingTrace" ADD CONSTRAINT "RoutingTrace_at_least_one_response_id" CHECK ("formResponseId" IS NOT NULL OR "queuedFormResponseId" IS NOT NULL);diff --git a/packages/prisma/schema.prisma b/packages/prisma/schema.prismaindex 63445723ab5..4497fd80714 100644--- a/packages/prisma/schema.prisma+++ b/packages/prisma/schema.prisma@@ -920,6 +920,7 @@ model Booking {routingFormResponses RoutingFormResponseDenormalized[]expenseLogs CreditExpenseLog[]report BookingReport?+ routingTrace RoutingTrace?// @@partial_index([reassignById])@@ -1349,6 +1350,8 @@ model App_RoutingForms_FormResponse {routingFormResponseFields RoutingFormResponseField[]routingFormResponses RoutingFormResponseDenormalized[]queuedFormResponse App_RoutingForms_QueuedFormResponse?+ pendingRoutingTrace PendingRoutingTrace?+ routingTrace RoutingTrace?@@unique([formFillerId, formId])@@index([formFillerId])@@ -1357,15 +1360,17 @@ model App_RoutingForms_FormResponse {}model App_RoutingForms_QueuedFormResponse {- id String @id @default(cuid())- form App_RoutingForms_Form @relation(fields: [formId], references: [id], onDelete: Cascade)- formId String- response Json- chosenRouteId String?- createdAt DateTime @default(now())- updatedAt DateTime? @updatedAt- actualResponseId Int? @unique- actualResponse App_RoutingForms_FormResponse? @relation(fields: [actualResponseId], references: [id], onDelete: Cascade)+ id String @id @default(cuid())+ form App_RoutingForms_Form @relation(fields: [formId], references: [id], onDelete: Cascade)+ formId String+ response Json+ chosenRouteId String?+ createdAt DateTime @default(now())+ updatedAt DateTime? @updatedAt+ actualResponseId Int? @unique+ actualResponse App_RoutingForms_FormResponse? @relation(fields: [actualResponseId], references: [id], onDelete: Cascade)+ pendingRoutingTrace PendingRoutingTrace?+ routingTrace RoutingTrace?}model RoutingFormResponseField {@@ -2334,6 +2339,7 @@ model AssignmentReason {booking Booking @relation(fields: [bookingId], references: [id], onDelete: Cascade)reasonEnum AssignmentReasonEnumreasonString String+ routingTrace RoutingTrace?@@index([bookingId])}@@ -3207,3 +3213,33 @@ model AttributeSyncFieldMapping {@@unique([integrationAttributeSyncId, attributeId])@@index([integrationAttributeSyncId])}++model PendingRoutingTrace {+ id String @id @default(uuid())+ createdAt DateTime @default(now())+ trace Json++ formResponseId Int? @unique+ formResponse App_RoutingForms_FormResponse? @relation(fields: [formResponseId], references: [id], onDelete: Cascade)++ queuedFormResponseId String? @unique+ queuedFormResponse App_RoutingForms_QueuedFormResponse? @relation(fields: [queuedFormResponseId], references: [id], onDelete: Cascade)+}++model RoutingTrace {+ id String @id @default(uuid())+ createdAt DateTime @default(now())+ trace Json++ formResponseId Int? @unique+ formResponse App_RoutingForms_FormResponse? @relation(fields: [formResponseId], references: [id], onDelete: Cascade)++ queuedFormResponseId String? @unique+ queuedFormResponse App_RoutingForms_QueuedFormResponse? @relation(fields: [queuedFormResponseId], references: [id], onDelete: Cascade)++ bookingUid String? @unique+ booking Booking? @relation(fields: [bookingUid], references: [uid], onDelete: Cascade)++ assignmentReasonId Int? @unique+ assignmentReason AssignmentReason? @relation(fields: [assignmentReasonId], references: [id], onDelete: Cascade)+}diff --git a/packages/trpc/server/routers/viewer/routing-forms/response.handler.ts b/packages/trpc/server/routers/viewer/routing-forms/response.handler.tsindex b89c9dfa4c3..39dd9d46eee 100644--- a/packages/trpc/server/routers/viewer/routing-forms/response.handler.ts+++ b/packages/trpc/server/routers/viewer/routing-forms/response.handler.ts@@ -1,5 +1,6 @@import { getSerializableForm } from "@calcom/app-store/routing-forms/lib/getSerializableForm";import { handleResponse } from "@calcom/features/routing-forms/lib/handleResponse";+import { getRoutingTraceService } from "@calcom/features/routing-trace/di/RoutingTraceService.container";import type { PrismaClient } from "@calcom/prisma";import { TRPCError } from "@trpc/server";@@ -46,14 +47,32 @@ export const responseHandler = async ({ ctx, input }: ResponseHandlerOptions) =>form,});- return handleResponse({+ // Initialize trace service for tracking routing decisions+ const traceService = isPreview ? undefined : getRoutingTraceService();++ const result = await handleResponse({response,identifierKeyedResponse: null,form: serializableForm,formFillerId,chosenRouteId,isPreview,+ traceService,});++ // Save the pending trace+ if (traceService) {+ const formResponseId = result.formResponse?.id;+ const queuedFormResponseId = result.queuedFormResponse?.id;++ if (formResponseId) {+ await traceService.savePendingRoutingTrace({ formResponseId });+ } else if (queuedFormResponseId) {+ await traceService.savePendingRoutingTrace({ queuedFormResponseId });+ }+ }++ return result;};export default responseHandler;