Scheduling infrastructure for absolutely everyone.
feat: Hubspot write to meeting object (#26039)
Amit Sharmaeacfcd15a416
diff --git a/apps/web/public/static/locales/en/common.json b/apps/web/public/static/locales/en/common.jsonindex 61a63f69381..ccc4558feb5 100644--- a/apps/web/public/static/locales/en/common.json+++ b/apps/web/public/static/locales/en/common.json@@ -3189,6 +3189,8 @@"rerouted_booking_successfully_redirecting_to_booking_page": "Rerouted booking successfully. Redirecting to booking page","on_booking_write_to_event_object": "On booking, write to event object","field_name": "Field name",+ "field_name_cannot_be_empty": "Field name cannot be empty",+ "field_already_exists": "Field already exists","add_new_field": "Add new field","you_dont_have_access_to_reroute_this_booking": "You don't have access to reroute this booking","form_response_not_found": "Form response not found",diff --git a/packages/app-store/_components/crm/WriteToObjectSettings.tsx b/packages/app-store/_components/crm/WriteToObjectSettings.tsxnew file mode 100644index 00000000000..0ff6f9c378c--- /dev/null+++ b/packages/app-store/_components/crm/WriteToObjectSettings.tsx@@ -0,0 +1,506 @@+import { useState, useMemo } from "react";++import { WhenToWrite } from "@calcom/app-store/_lib/crm-enums";+import { useLocale } from "@calcom/lib/hooks/useLocale";+import { Button } from "@calcom/ui/components/button";+import { Switch } from "@calcom/ui/components/form";+import { InputField } from "@calcom/ui/components/form";+import { Select } from "@calcom/ui/components/form";+import { Section } from "@calcom/ui/components/section";+import { showToast } from "@calcom/ui/components/toast";++import type { WriteToRecordEntrySchema, WriteToObjectSettingsProps } from "./WriteToObjectSettings.types";+import {+ DATE_FIELD_TYPE,+ CHECKBOX_FIELD_TYPE,+ buildFieldTypeOptions,+ buildDateFieldValueOptions,+ buildWhenToWriteOptions,+ buildCheckboxFieldValueOptions,+} from "./WriteToObjectSettings.utils";++const WriteToObjectSettings = ({+ bookingAction,+ optionLabel,+ optionEnabled,+ optionSwitchOnChange,+ writeToObjectData,+ updateWriteToObjectData,+ supportedFieldTypes,+ supportedDateFields,+ supportedWriteTriggers = [WhenToWrite.EVERY_BOOKING, WhenToWrite.FIELD_EMPTY],+}: WriteToObjectSettingsProps) => {+ const { t } = useLocale();++ const fieldTypeOptions = useMemo(+ () => buildFieldTypeOptions(supportedFieldTypes, t),+ [supportedFieldTypes, t]+ );++ const dateFieldValueOptions = useMemo(+ () => buildDateFieldValueOptions(bookingAction, supportedDateFields, t),+ [supportedDateFields, bookingAction, t]+ );++ const whenToWriteOptions = useMemo(+ () => buildWhenToWriteOptions(supportedWriteTriggers, bookingAction, t),+ [supportedWriteTriggers, bookingAction, t]+ );++ const showWhenToWriteColumn = whenToWriteOptions.length > 1;++ const checkboxFieldValueOptions = useMemo(() => buildCheckboxFieldValueOptions(t), [t]);++ const [fieldTypeSelectedOption, setFieldTypeSelectedOption] = useState(fieldTypeOptions[0]);+ const [dateFieldSelectedOption, setDateFieldSelectedOption] = useState(dateFieldValueOptions[0]);+ const [checkboxFieldSelectedOption, setCheckboxFieldSelectedOption] = useState(+ checkboxFieldValueOptions[0]+ );+ const [whenToWriteSelectedOption, setWhenToWriteSelectedOption] = useState(whenToWriteOptions[0]);+ const [editingRows, setEditingRows] = useState<Record<string, boolean>>({});+ const [editingData, setEditingData] = useState<Record<string, WriteToRecordEntrySchema>>({});+ const [newOnWriteToRecordEntry, setNewOnWriteToRecordEntry] = useState<WriteToRecordEntrySchema>({+ field: "",+ fieldType: fieldTypeSelectedOption.value,+ value: "",+ whenToWrite: whenToWriteSelectedOption.value,+ });++ const startEditing = (key: string) => {+ Object.keys(editingRows).forEach((rowKey) => {+ if (editingRows[rowKey] && rowKey !== key) {+ cancelEditing(rowKey);+ }+ });+ setEditingRows((prev) => ({ ...prev, [key]: true }));+ setEditingData((prev) => ({+ ...prev,+ [key]: {+ field: key,+ fieldType: writeToObjectData[key].fieldType,+ value: writeToObjectData[key].value,+ whenToWrite: writeToObjectData[key].whenToWrite,+ },+ }));+ };++ const cancelEditing = (key: string) => {+ setEditingRows((prev) => ({ ...prev, [key]: false }));+ setEditingData((prev) => {+ const newData = { ...prev };+ delete newData[key];+ return newData;+ });+ };++ const saveEditing = (key: string) => {+ const editData = editingData[key];+ if (!editData) return;++ if (!editData.field.trim()) {+ showToast(t("field_name_cannot_be_empty"), "error");+ return;+ }++ if (editData.field !== key && Object.keys(writeToObjectData).includes(editData.field.trim())) {+ showToast(t("field_already_exists"), "error");+ return;+ }++ const newWriteToObjectData = { ...writeToObjectData };++ if (editData.field !== key) {+ delete newWriteToObjectData[key];+ }++ newWriteToObjectData[editData.field.trim()] = {+ fieldType: editData.fieldType,+ value: editData.value,+ whenToWrite: editData.whenToWrite,+ };++ updateWriteToObjectData(newWriteToObjectData);+ cancelEditing(key);+ };++ return (+ <>+ <Section.SubSectionHeader icon="star" labelFor="write-to-object-settings" title={optionLabel}>+ <Switch+ checked={optionEnabled}+ onCheckedChange={optionSwitchOnChange}+ id="write-to-object-settings"+ size="sm"+ />+ </Section.SubSectionHeader>++ {optionEnabled ? (+ <Section.SubSectionContent>+ <div className="text-subtle flex gap-3 px-3 py-[6px] text-sm font-medium">+ <div className="flex-1">{t("field_name")}</div>+ <div className="flex-1">{t("field_type")}</div>+ <div className="flex-1">{t("value")}</div>+ {showWhenToWriteColumn && <div className="flex-1">{t("when_to_write")}</div>}+ <div className="w-20" />+ </div>+ <Section.SubSectionNested>+ {Object.keys(writeToObjectData).map((key) => {+ const isEditing = editingRows[key];+ const editData = editingData[key];++ return (+ <div className="flex items-center gap-2" key={key}>+ <div className="flex-1">+ {isEditing ? (+ <InputField+ value={editData?.field || key}+ onChange={(e) =>+ setEditingData((prev) => ({+ ...prev,+ [key]: { ...editData, field: e.target.value },+ }))+ }+ size="sm"+ className="w-full"+ />+ ) : (+ <InputField value={key} readOnly size="sm" className="w-full" />+ )}+ </div>+ <div className="flex-1">+ {isEditing ? (+ <Select+ size="sm"+ className="w-full"+ options={fieldTypeOptions}+ value={fieldTypeOptions.find((option) => option.value === editData?.fieldType)}+ onChange={(e) => {+ if (e) {+ setEditingData((prev) => ({+ ...prev,+ [key]: {+ ...editData,+ fieldType: e.value,+ ...(e.value === DATE_FIELD_TYPE && {+ value: dateFieldValueOptions[0].value,+ }),+ ...(e.value === CHECKBOX_FIELD_TYPE && {+ value: checkboxFieldValueOptions[0].value,+ }),+ },+ }));+ }+ }}+ />+ ) : (+ <Select+ size="sm"+ className="w-full"+ value={fieldTypeOptions.find(+ (option) => option.value === writeToObjectData[key].fieldType+ )}+ isDisabled={true}+ />+ )}+ </div>+ <div className="flex-1">+ {isEditing ? (+ editData?.fieldType === DATE_FIELD_TYPE ? (+ <Select+ size="sm"+ className="w-full"+ options={dateFieldValueOptions}+ value={dateFieldValueOptions.find((option) => option.value === editData.value)}+ onChange={(e) => {+ if (e) {+ setEditingData((prev) => ({+ ...prev,+ [key]: { ...editData, value: e.value },+ }));+ }+ }}+ />+ ) : editData?.fieldType === CHECKBOX_FIELD_TYPE ? (+ <Select+ size="sm"+ className="w-full"+ options={checkboxFieldValueOptions}+ value={checkboxFieldValueOptions.find((option) => option.value === editData.value)}+ onChange={(e) => {+ if (e) {+ setEditingData((prev) => ({+ ...prev,+ [key]: { ...editData, value: e.value },+ }));+ }+ }}+ />+ ) : (+ <InputField+ value={(editData?.value as string) || ""}+ onChange={(e) =>+ setEditingData((prev) => ({+ ...prev,+ [key]: { ...editData, value: e.target.value },+ }))+ }+ size="sm"+ className="w-full"+ />+ )+ ) : writeToObjectData[key].fieldType === DATE_FIELD_TYPE ? (+ <Select+ size="sm"+ className="w-full"+ value={dateFieldValueOptions.find(+ (option) => option.value === writeToObjectData[key].value+ )}+ isDisabled={true}+ />+ ) : writeToObjectData[key].fieldType === CHECKBOX_FIELD_TYPE ? (+ <Select+ size="sm"+ className="w-full"+ value={checkboxFieldValueOptions.find(+ (option) => option.value === writeToObjectData[key].value+ )}+ isDisabled={true}+ />+ ) : (+ <InputField+ value={writeToObjectData[key].value as string}+ readOnly+ size="sm"+ className="w-full"+ />+ )}+ </div>+ {showWhenToWriteColumn && (+ <div className="flex-1">+ {isEditing ? (+ <Select+ size="sm"+ className="w-full"+ options={whenToWriteOptions}+ value={whenToWriteOptions.find((option) => option.value === editData?.whenToWrite)}+ onChange={(e) => {+ if (e) {+ setEditingData((prev) => ({+ ...prev,+ [key]: { ...editData, whenToWrite: e.value },+ }));+ }+ }}+ />+ ) : (+ <Select+ size="sm"+ className="w-full"+ value={whenToWriteOptions.find(+ (option) => option.value === writeToObjectData[key].whenToWrite+ )}+ isDisabled={true}+ />+ )}+ </div>+ )}+ <div className="flex w-20 justify-center gap-1">+ {isEditing ? (+ <>+ <Button+ size="sm"+ StartIcon="check"+ variant="icon"+ color="primary"+ onClick={() => saveEditing(key)}+ />+ <Button+ size="sm"+ StartIcon="x"+ variant="icon"+ color="secondary"+ onClick={() => cancelEditing(key)}+ />+ </>+ ) : (+ <>+ <Button+ size="sm"+ StartIcon="pencil"+ variant="icon"+ color="minimal"+ onClick={() => startEditing(key)}+ />+ <Button+ size="sm"+ StartIcon="x"+ variant="icon"+ color="minimal"+ onClick={() => {+ const newObject = { ...writeToObjectData };+ delete newObject[key];+ updateWriteToObjectData(newObject);+ }}+ />+ </>+ )}+ </div>+ </div>+ );+ })}+ <div className="flex gap-2">+ <div className="flex-1">+ <InputField+ size="sm"+ className="w-full"+ value={newOnWriteToRecordEntry.field}+ onChange={(e) =>+ setNewOnWriteToRecordEntry({+ ...newOnWriteToRecordEntry,+ field: e.target.value,+ })+ }+ />+ </div>+ <div className="flex-1">+ <Select+ size="sm"+ className="w-full"+ options={fieldTypeOptions}+ value={fieldTypeSelectedOption}+ onChange={(e) => {+ if (e) {+ setFieldTypeSelectedOption(e);+ setNewOnWriteToRecordEntry({+ ...newOnWriteToRecordEntry,+ fieldType: e.value,+ ...(e.value === DATE_FIELD_TYPE && { value: dateFieldSelectedOption.value }),+ ...(e.value === CHECKBOX_FIELD_TYPE && {+ value: checkboxFieldSelectedOption.value,+ }),+ });+ }+ }}+ />+ </div>+ <div className="flex-1">+ {newOnWriteToRecordEntry.fieldType === DATE_FIELD_TYPE ? (+ <Select+ size="sm"+ className="w-full"+ options={dateFieldValueOptions}+ value={dateFieldSelectedOption}+ onChange={(e) => {+ if (e) {+ setDateFieldSelectedOption(e);+ setNewOnWriteToRecordEntry({+ ...newOnWriteToRecordEntry,+ value: e.value,+ });+ }+ }}+ />+ ) : newOnWriteToRecordEntry.fieldType === CHECKBOX_FIELD_TYPE ? (+ <Select+ size="sm"+ className="w-full"+ options={checkboxFieldValueOptions}+ value={checkboxFieldSelectedOption}+ onChange={(e) => {+ if (e) {+ setCheckboxFieldSelectedOption(e);+ setNewOnWriteToRecordEntry({+ ...newOnWriteToRecordEntry,+ value: e.value,+ });+ }+ }}+ />+ ) : (+ <InputField+ size="sm"+ className="w-full"+ value={newOnWriteToRecordEntry.value as string}+ onChange={(e) =>+ setNewOnWriteToRecordEntry({+ ...newOnWriteToRecordEntry,+ value: e.target.value,+ })+ }+ />+ )}+ </div>+ {showWhenToWriteColumn && (+ <div className="flex-1">+ <Select+ size="sm"+ className="w-full"+ options={whenToWriteOptions}+ value={whenToWriteSelectedOption}+ onChange={(e) => {+ if (e) {+ setWhenToWriteSelectedOption(e);+ setNewOnWriteToRecordEntry({+ ...newOnWriteToRecordEntry,+ whenToWrite: e.value,+ });+ }+ }}+ />+ </div>+ )}+ <div className="w-20" />+ </div>+ </Section.SubSectionNested>+ <Button+ className="text-subtle mt-2 w-fit"+ StartIcon="plus"+ color="minimal"+ size="sm"+ disabled={+ !(+ newOnWriteToRecordEntry.field &&+ newOnWriteToRecordEntry.fieldType &&+ newOnWriteToRecordEntry.value !== "" &&+ newOnWriteToRecordEntry.whenToWrite+ )+ }+ onClick={() => {+ if (Object.keys(writeToObjectData).includes(newOnWriteToRecordEntry.field.trim())) {+ showToast(t("field_already_exists"), "error");+ return;+ }++ updateWriteToObjectData({+ ...writeToObjectData,+ [newOnWriteToRecordEntry.field.trim()]: {+ fieldType: newOnWriteToRecordEntry.fieldType,+ value: newOnWriteToRecordEntry.value,+ whenToWrite: newOnWriteToRecordEntry.whenToWrite,+ },+ });++ setNewOnWriteToRecordEntry({+ field: "",+ fieldType: fieldTypeOptions[0].value,+ value: "",+ whenToWrite: whenToWriteOptions[0].value,+ });+ }}>+ {t("add_new_field")}+ </Button>+ </Section.SubSectionContent>+ ) : null}+ </>+ );+};++export {+ BookingActionEnum,+ type SelectOption,+ type WriteToRecordEntry,+ type WriteToRecordEntrySchema,+ type WriteToObjectSettingsProps,+} from "./WriteToObjectSettings.types";++export default WriteToObjectSettings;diff --git a/packages/app-store/_components/crm/WriteToObjectSettings.types.ts b/packages/app-store/_components/crm/WriteToObjectSettings.types.tsnew file mode 100644index 00000000000..82d24165289--- /dev/null+++ b/packages/app-store/_components/crm/WriteToObjectSettings.types.ts@@ -0,0 +1,38 @@+import { CrmFieldType, WhenToWrite } from "@calcom/app-store/_lib/crm-enums";++export { CrmFieldType, DateFieldType, WhenToWrite } from "@calcom/app-store/_lib/crm-enums";++export enum BookingActionEnum {+ ON_BOOKING = "on_booking",+ ON_CANCEL = "on_cancel",+}++export interface SelectOption<T = string> {+ label: string;+ value: T;+}++export interface WriteToRecordEntry {+ fieldType: CrmFieldType;+ value: string | boolean;+ whenToWrite: WhenToWrite;+}++export interface WriteToRecordEntrySchema {+ field: string;+ fieldType: CrmFieldType;+ value: string | boolean;+ whenToWrite: WhenToWrite;+}++export interface WriteToObjectSettingsProps {+ bookingAction: BookingActionEnum;+ optionLabel: string;+ optionEnabled: boolean;+ optionSwitchOnChange: (checked: boolean) => void;+ writeToObjectData: Record<string, WriteToRecordEntry>;+ updateWriteToObjectData: (data: Record<string, WriteToRecordEntry>) => void;+ supportedFieldTypes: readonly CrmFieldType[];+ supportedDateFields?: readonly import("@calcom/app-store/_lib/crm-enums").DateFieldType[];+ supportedWriteTriggers?: readonly WhenToWrite[];+}diff --git a/packages/app-store/_components/crm/WriteToObjectSettings.utils.ts b/packages/app-store/_components/crm/WriteToObjectSettings.utils.tsnew file mode 100644index 00000000000..30a30fbcba9--- /dev/null+++ b/packages/app-store/_components/crm/WriteToObjectSettings.utils.ts@@ -0,0 +1,70 @@+import { CrmFieldType, DateFieldType, WhenToWrite } from "@calcom/app-store/_lib/crm-enums";++import type { SelectOption } from "./WriteToObjectSettings.types";+import { BookingActionEnum } from "./WriteToObjectSettings.types";++export const DATE_FIELD_TYPE = CrmFieldType.DATE;+export const CHECKBOX_FIELD_TYPE = CrmFieldType.CHECKBOX;++export const FIELD_TYPE_LABELS: Record<CrmFieldType, string> = {+ [CrmFieldType.TEXT]: "text",+ [CrmFieldType.STRING]: "text",+ [CrmFieldType.DATE]: "date",+ [CrmFieldType.DATETIME]: "datetime",+ [CrmFieldType.PHONE]: "phone",+ [CrmFieldType.CHECKBOX]: "checkbox",+ [CrmFieldType.PICKLIST]: "picklist",+ [CrmFieldType.CUSTOM]: "custom",+ [CrmFieldType.TEXTAREA]: "textarea",+};++export const DATE_FIELD_LABEL_MAP: Record<DateFieldType, string> = {+ [DateFieldType.BOOKING_CANCEL_DATE]: "booking_cancel_date",+ [DateFieldType.BOOKING_START_DATE]: "booking_start_date",+ [DateFieldType.BOOKING_CREATED_DATE]: "booking_created_date",+};++export const getWhenToWriteLabelMap = (+ bookingAction: BookingActionEnum+): Record<WhenToWrite, string> => ({+ [WhenToWrite.EVERY_BOOKING]:+ bookingAction === BookingActionEnum.ON_CANCEL ? "salesforce_on_every_cancellation" : "on_every_booking",+ [WhenToWrite.FIELD_EMPTY]: "only_if_field_is_empty",+});++export const buildFieldTypeOptions = (+ supportedFieldTypes: readonly CrmFieldType[],+ t: (key: string) => string+): SelectOption<CrmFieldType>[] =>+ supportedFieldTypes.map((type) => ({+ label: t(FIELD_TYPE_LABELS[type]),+ value: type,+ }));++export const buildDateFieldValueOptions = (+ bookingAction: BookingActionEnum,+ supportedDateFields: readonly DateFieldType[] | undefined,+ t: (key: string) => string+): SelectOption<DateFieldType>[] => {+ const defaultDateFields =+ bookingAction === BookingActionEnum.ON_CANCEL+ ? [DateFieldType.BOOKING_CANCEL_DATE, DateFieldType.BOOKING_START_DATE, DateFieldType.BOOKING_CREATED_DATE]+ : [DateFieldType.BOOKING_START_DATE, DateFieldType.BOOKING_CREATED_DATE];++ const fields = supportedDateFields ?? defaultDateFields;+ return fields.map((type) => ({ label: t(DATE_FIELD_LABEL_MAP[type]), value: type }));+};++export const buildWhenToWriteOptions = (+ supportedWriteTriggers: readonly WhenToWrite[],+ bookingAction: BookingActionEnum,+ t: (key: string) => string+): SelectOption<WhenToWrite>[] => {+ const labelMap = getWhenToWriteLabelMap(bookingAction);+ return supportedWriteTriggers.map((trigger) => ({ label: t(labelMap[trigger]), value: trigger }));+};++export const buildCheckboxFieldValueOptions = (t: (key: string) => string): SelectOption<boolean>[] => [+ { label: t("true"), value: true },+ { label: t("false"), value: false },+];diff --git a/packages/app-store/_lib/crm-enums.ts b/packages/app-store/_lib/crm-enums.tsnew file mode 100644index 00000000000..c158815f37c--- /dev/null+++ b/packages/app-store/_lib/crm-enums.ts@@ -0,0 +1,37 @@+/**+ * CRM field types supported across different CRM integrations.+ *+ * Implementation notes:+ * - TEXT, STRING, PHONE, TEXTAREA, CUSTOM: All handled identically as text fields+ * - DATE, DATETIME: Both handled identically, return ISO 8601 datetime strings+ * - CHECKBOX: Returns boolean values (true/false)+ * - PICKLIST: Dropdown/select fields+ */+export enum CrmFieldType {+ TEXT = "text",+ STRING = "string",+ DATE = "date",+ DATETIME = "datetime",+ PHONE = "phone",+ CHECKBOX = "checkbox",+ PICKLIST = "picklist",+ CUSTOM = "custom",+ TEXTAREA = "textarea",+}++export enum DateFieldType {+ BOOKING_START_DATE = "booking_start_date",+ BOOKING_CREATED_DATE = "booking_created_date",+ BOOKING_CANCEL_DATE = "booking_cancel_date",+}++/**+ * Controls when CRM field values should be written.+ *+ * - EVERY_BOOKING: Always write the value on every booking+ * - FIELD_EMPTY: Only write if the field is currently empty (prevents overwrites)+ */+export enum WhenToWrite {+ EVERY_BOOKING = "every_booking",+ FIELD_EMPTY = "field_empty",+}diff --git a/packages/app-store/_lib/crm-schemas.ts b/packages/app-store/_lib/crm-schemas.tsnew file mode 100644index 00000000000..0fd17950e5c--- /dev/null+++ b/packages/app-store/_lib/crm-schemas.ts@@ -0,0 +1,16 @@+import { z } from "zod";++import { CrmFieldType, WhenToWrite } from "./crm-enums";++export const writeToBookingEntry = z.object({+ value: z.union([z.string(), z.boolean()]),+ fieldType: z.nativeEnum(CrmFieldType),+ whenToWrite: z.nativeEnum(WhenToWrite),+});++export const writeToRecordEntrySchema = z.object({+ field: z.string(),+ fieldType: z.nativeEnum(CrmFieldType),+ value: z.union([z.string(), z.boolean()]),+ whenToWrite: z.nativeEnum(WhenToWrite),+});diff --git a/packages/app-store/hubspot/components/EventTypeAppCardInterface.tsx b/packages/app-store/hubspot/components/EventTypeAppCardInterface.tsxindex 4b529c67218..37c82ff6db8 100644--- a/packages/app-store/hubspot/components/EventTypeAppCardInterface.tsx+++ b/packages/app-store/hubspot/components/EventTypeAppCardInterface.tsx@@ -2,6 +2,10 @@ import { usePathname } from "next/navigation";import { useAppContextWithSchema } from "@calcom/app-store/EventTypeAppContext";import AppCard from "@calcom/app-store/_components/AppCard";+import { CrmFieldType } from "@calcom/app-store/_lib/crm-enums";+import WriteToObjectSettings, {+ BookingActionEnum,+} from "@calcom/app-store/_components/crm/WriteToObjectSettings";import useIsAppEnabled from "@calcom/app-store/_utils/useIsAppEnabled";import type { EventTypeAppCardComponent } from "@calcom/app-store/types";import { WEBAPP_URL } from "@calcom/lib/constants";@@ -10,6 +14,7 @@ import { Switch } from "@calcom/ui/components/form";import { Section } from "@calcom/ui/components/section";import type { appDataSchema } from "../zod";+import { WhenToWrite } from "../zod";const EventTypeAppCard: EventTypeAppCardComponent = function EventTypeAppCard({app,@@ -23,6 +28,8 @@ const EventTypeAppCard: EventTypeAppCardComponent = function EventTypeAppCard({const ignoreGuests = getAppData("ignoreGuests") ?? false;const skipContactCreation = getAppData("skipContactCreation") ?? false;+ const onBookingWriteToEventObject = getAppData("onBookingWriteToEventObject") ?? false;+ const onBookingWriteToEventObjectFields = getAppData("onBookingWriteToEventObjectFields") ?? {};return (<AppCard@@ -66,6 +73,27 @@ const EventTypeAppCard: EventTypeAppCardComponent = function EventTypeAppCard({/></Section.SubSectionHeader></Section.SubSection>++ <Section.SubSection>+ <WriteToObjectSettings+ bookingAction={BookingActionEnum.ON_BOOKING}+ optionLabel={t("on_booking_write_to_event_object")}+ optionEnabled={onBookingWriteToEventObject}+ writeToObjectData={onBookingWriteToEventObjectFields}+ optionSwitchOnChange={(checked) => {+ setAppData("onBookingWriteToEventObject", checked);+ }}+ updateWriteToObjectData={(data) => setAppData("onBookingWriteToEventObjectFields", data)}+ supportedFieldTypes={[+ CrmFieldType.TEXT,+ CrmFieldType.DATE,+ CrmFieldType.PHONE,+ CrmFieldType.CHECKBOX,+ CrmFieldType.CUSTOM,+ ]}+ supportedWriteTriggers={[WhenToWrite.EVERY_BOOKING]}+ />+ </Section.SubSection></Section.Content></AppCard>);diff --git a/packages/app-store/hubspot/lib/CrmService.test.ts b/packages/app-store/hubspot/lib/CrmService.test.tsnew file mode 100644index 00000000000..0f5c099e0f0--- /dev/null+++ b/packages/app-store/hubspot/lib/CrmService.test.ts@@ -0,0 +1,797 @@+import type { TFunction } from "i18next";++import type { CalendarEvent } from "@calcom/types/Calendar";+import type { CredentialPayload } from "@calcom/types/Credential";+import { setupAndTeardown } from "@calcom/web/test/utils/bookingScenario/setupAndTeardown";+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+import type { z } from "zod";++import { CrmFieldType, DateFieldType, WhenToWrite } from "../../_lib/crm-enums";+import type { appDataSchema } from "../zod";++type AppOptions = z.infer<typeof appDataSchema>;++// Create hoisted mocks that will be available before module imports+const {+ mockHubspotClient,+ mockGetAppKeysFromSlug,+}: {+ mockHubspotClient: {+ crm: {+ properties: { coreApi: { getAll: ReturnType<typeof vi.fn> } };+ contacts: {+ searchApi: { doSearch: ReturnType<typeof vi.fn> };+ basicApi: { create: ReturnType<typeof vi.fn> };+ };+ objects: {+ meetings: {+ basicApi: {+ create: ReturnType<typeof vi.fn>;+ update: ReturnType<typeof vi.fn>;+ archive: ReturnType<typeof vi.fn>;+ };+ };+ };+ associations: { batchApi: { create: ReturnType<typeof vi.fn> } };+ owners: { ownersApi: { getPage: ReturnType<typeof vi.fn> } };+ };+ oauth: { tokensApi: { createToken: ReturnType<typeof vi.fn> } };+ setAccessToken: ReturnType<typeof vi.fn>;+ };+ mockGetAppKeysFromSlug: ReturnType<typeof vi.fn>;+} = vi.hoisted(() => {+ const mockHubspotClient = {+ crm: {+ properties: {+ coreApi: {+ getAll: vi.fn(),+ },+ },+ contacts: {+ searchApi: {+ doSearch: vi.fn(),+ },+ basicApi: {+ create: vi.fn(),+ },+ },+ objects: {+ meetings: {+ basicApi: {+ create: vi.fn(),+ update: vi.fn(),+ archive: vi.fn(),+ },+ },+ },+ associations: {+ batchApi: {+ create: vi.fn(),+ },+ },+ owners: {+ ownersApi: {+ getPage: vi.fn(),+ },+ },+ },+ oauth: {+ tokensApi: {+ createToken: vi.fn(),+ },+ },+ setAccessToken: vi.fn(),+ };++ const mockGetAppKeysFromSlug = vi.fn().mockResolvedValue({+ client_id: "mock_client_id",+ client_secret: "mock_client_secret",+ });++ return { mockHubspotClient, mockGetAppKeysFromSlug };+});++vi.mock("@hubspot/api-client", () => {+ return {+ Client: class {+ crm = mockHubspotClient.crm;+ oauth = mockHubspotClient.oauth;+ setAccessToken = mockHubspotClient.setAccessToken;+ },+ };+});++vi.mock("../../_utils/getAppKeysFromSlug", () => ({+ default: mockGetAppKeysFromSlug,+}));++vi.mock("@calcom/prisma", () => ({+ default: {+ credential: {+ update: vi.fn(),+ },+ },+}));++import HubspotCalendarService from "./CrmService";++describe("HubspotCalendarService", () => {+ let service: HubspotCalendarService;+ let mockTrackingRepository: {+ findByBookingUid: ReturnType<typeof vi.fn>;+ };+ let mockBookingRepository: {+ findBookingByUid: ReturnType<typeof vi.fn>;+ };++ setupAndTeardown();++ beforeEach(() => {+ vi.useFakeTimers();+ vi.setSystemTime(new Date("2024-01-15T10:00:00.000Z"));++ // Re-apply mock implementation for getAppKeysFromSlug (needed after clearAllMocks)+ mockGetAppKeysFromSlug.mockResolvedValue({+ client_id: "mock_client_id",+ client_secret: "mock_client_secret",+ });++ mockTrackingRepository = {+ findByBookingUid: vi.fn(),+ };++ mockBookingRepository = {+ findBookingByUid: vi.fn(),+ };++ const mockCredential: CredentialPayload = {+ id: 1,+ type: "hubspot_other_calendar",+ key: {+ accessToken: "mock_token",+ refreshToken: "mock_refresh",+ expiryDate: Date.now() + 3600000,+ tokenType: "Bearer",+ },+ userId: 1,+ appId: "hubspot",+ teamId: null,+ invalid: false,+ user: {+ email: "[email protected]",+ },+ delegationCredentialId: null,+ };++ service = new HubspotCalendarService(mockCredential, {});++ // @ts-expect-error - Injecting mock repositories for testing+ service.trackingRepository = mockTrackingRepository;+ // @ts-expect-error - Injecting mock repositories for testing+ service.bookingRepository = mockBookingRepository;+ // @ts-expect-error - Injecting mock hubspot client for testing+ service.hubspotClient = mockHubspotClient;+ // @ts-expect-error - Mocking auth promise to prevent unhandled rejections+ service.auth = Promise.resolve({ getToken: vi.fn() });+ });++ afterEach(() => {+ vi.useRealTimers();+ vi.clearAllMocks();+ });++ function mockAppOptions(appOptions: AppOptions): void {+ const appOptionsSpy = vi.spyOn(service, "getAppOptions");+ appOptionsSpy.mockReturnValue(appOptions);+ }++ // Helper to create a mock CalendarEvent+ function createMockEvent(overrides: Partial<CalendarEvent> = {}): CalendarEvent {+ return {+ type: "test-event",+ title: "Test Meeting",+ startTime: "2024-01-20T14:00:00.000Z",+ endTime: "2024-01-20T15:00:00.000Z",+ uid: "booking-123",+ responses: {+ name: { label: "Name", value: "John Doe" },+ email: { label: "Email", value: "[email protected]" },+ },+ // customInputs is required by getLabelValueMapFromResponses when userFieldsResponses is not present+ customInputs: {},+ organizer: {+ email: "[email protected]",+ name: "Organizer",+ timeZone: "America/New_York",+ language: {+ translate: ((key: string) => key) as TFunction,+ locale: "en",+ },+ },+ attendees: [+ {+ email: "[email protected]",+ name: "Attendee",+ timeZone: "America/New_York",+ language: {+ translate: ((key: string) => key) as TFunction,+ locale: "en",+ },+ },+ ],+ ...overrides,+ };+ }++ // Helper to setup common mocks for createEvent tests+ function setupCreateEventMocks(): void {+ // Mock owner lookup - return empty results (no owner found)+ mockHubspotClient.crm.owners.ownersApi.getPage.mockResolvedValue({ results: [] });++ // Mock meeting creation+ mockHubspotClient.crm.objects.meetings.basicApi.create.mockResolvedValue({+ id: "meeting-123",+ properties: {},+ });++ // Mock association creation+ mockHubspotClient.crm.associations.batchApi.create.mockResolvedValue({+ results: [],+ });+ }++ describe("getContacts", () => {+ it("should return contacts when found", async () => {+ mockHubspotClient.crm.contacts.searchApi.doSearch.mockResolvedValueOnce({+ results: [+ { id: "contact-1", properties: { email: "[email protected]" } },+ { id: "contact-2", properties: { email: "[email protected]" } },+ ],+ });++ const result = await service.getContacts({ emails: ["[email protected]", "[email protected]"] });++ expect(result).toEqual([+ { id: "contact-1", email: "[email protected]" },+ { id: "contact-2", email: "[email protected]" },+ ]);+ });++ it("should handle single email string input", async () => {+ mockHubspotClient.crm.contacts.searchApi.doSearch.mockResolvedValueOnce({+ results: [{ id: "contact-1", properties: { email: "[email protected]" } }],+ });++ const result = await service.getContacts({ emails: "[email protected]" });++ expect(result).toEqual([{ id: "contact-1", email: "[email protected]" }]);+ });++ it("should return empty array when no contacts found", async () => {+ mockHubspotClient.crm.contacts.searchApi.doSearch.mockResolvedValueOnce({+ results: [],+ });++ const result = await service.getContacts({ emails: "[email protected]" });++ expect(result).toEqual([]);+ });+ });++ describe("createContacts", () => {+ it("should create contacts successfully", async () => {+ mockHubspotClient.crm.contacts.basicApi.create.mockResolvedValueOnce({+ id: "new-contact-1",+ properties: { email: "[email protected]", firstname: "New", lastname: "Contact" },+ });++ const result = await service.createContacts([{ name: "New Contact", email: "[email protected]" }]);++ expect(result).toEqual([{ id: "new-contact-1", email: "[email protected]" }]);+ expect(mockHubspotClient.crm.contacts.basicApi.create).toHaveBeenCalledWith({+ properties: {+ firstname: "New",+ lastname: "Contact",+ email: "[email protected]",+ },+ });+ });++ it("should handle existing contact error gracefully", async () => {+ mockHubspotClient.crm.contacts.basicApi.create.mockRejectedValueOnce({+ body: { message: "Contact already exists. Existing ID: existing-contact-123" },+ });++ const result = await service.createContacts([+ { name: "Existing Contact", email: "[email protected]" },+ ]);++ expect(result).toEqual([{ id: "existing-contact-123", email: "[email protected]" }]);+ });+ });++ describe("createEvent", () => {+ it("should create a meeting without custom fields when feature is disabled", async () => {+ mockAppOptions({});+ setupCreateEventMocks();++ const event = createMockEvent();+ const contacts = [{ id: "contact-1", email: "[email protected]" }];++ await service.createEvent(event, contacts);++ // Verify meeting was created with standard properties only+ expect(mockHubspotClient.crm.objects.meetings.basicApi.create).toHaveBeenCalledWith({+ properties: expect.objectContaining({+ hs_meeting_title: "Test Meeting",+ hs_meeting_outcome: "SCHEDULED",+ }),+ });++ // Verify no custom fields were included+ const createCall = mockHubspotClient.crm.objects.meetings.basicApi.create.mock.calls[0][0];+ expect(createCall.properties).not.toHaveProperty("custom_name");+ });++ it("should include custom text field with static value", async () => {+ mockAppOptions({+ onBookingWriteToEventObject: true,+ onBookingWriteToEventObjectFields: {+ custom_source: {+ fieldType: CrmFieldType.TEXT,+ value: "Cal.com Booking",+ whenToWrite: WhenToWrite.EVERY_BOOKING,+ },+ },+ });+ setupCreateEventMocks();++ // Mock field validation - field exists on HubSpot+ mockHubspotClient.crm.properties.coreApi.getAll.mockResolvedValueOnce({+ results: [{ name: "custom_source", type: "string" }],+ });++ const event = createMockEvent();+ const contacts = [{ id: "contact-1", email: "[email protected]" }];++ await service.createEvent(event, contacts);++ const createCall = mockHubspotClient.crm.objects.meetings.basicApi.create.mock.calls[0][0];+ expect(createCall.properties.custom_source).toBe("Cal.com Booking");+ });++ it("should include custom text field with booking response placeholder", async () => {+ mockAppOptions({+ onBookingWriteToEventObject: true,+ onBookingWriteToEventObjectFields: {+ attendee_name: {+ fieldType: CrmFieldType.TEXT,+ value: "{name}",+ whenToWrite: WhenToWrite.EVERY_BOOKING,+ },+ },+ });+ setupCreateEventMocks();++ mockHubspotClient.crm.properties.coreApi.getAll.mockResolvedValueOnce({+ results: [{ name: "attendee_name", type: "string" }],+ });++ const event = createMockEvent({+ responses: {+ name: { label: "Name", value: "John Doe" },+ },+ });+ const contacts = [{ id: "contact-1", email: "[email protected]" }];++ await service.createEvent(event, contacts);++ const createCall = mockHubspotClient.crm.objects.meetings.basicApi.create.mock.calls[0][0];+ expect(createCall.properties.attendee_name).toBe("John Doe");+ });++ it("should include custom text field with UTM tracking value", async () => {+ mockAppOptions({+ onBookingWriteToEventObject: true,+ onBookingWriteToEventObjectFields: {+ utm_source_field: {+ fieldType: CrmFieldType.TEXT,+ value: "{utm:source}",+ whenToWrite: WhenToWrite.EVERY_BOOKING,+ },+ },+ });+ setupCreateEventMocks();++ mockHubspotClient.crm.properties.coreApi.getAll.mockResolvedValueOnce({+ results: [{ name: "utm_source_field", type: "string" }],+ });++ mockTrackingRepository.findByBookingUid.mockResolvedValueOnce({+ utm_source: "google_ads",+ utm_medium: "cpc",+ });++ const event = createMockEvent();+ const contacts = [{ id: "contact-1", email: "[email protected]" }];++ await service.createEvent(event, contacts);++ const createCall = mockHubspotClient.crm.objects.meetings.basicApi.create.mock.calls[0][0];+ expect(createCall.properties.utm_source_field).toBe("google_ads");+ });++ it("should include checkbox field with boolean value", async () => {+ mockAppOptions({+ onBookingWriteToEventObject: true,+ onBookingWriteToEventObjectFields: {+ is_confirmed: {+ fieldType: CrmFieldType.CHECKBOX,+ value: true,+ whenToWrite: WhenToWrite.EVERY_BOOKING,+ },+ },+ });+ setupCreateEventMocks();++ mockHubspotClient.crm.properties.coreApi.getAll.mockResolvedValueOnce({+ results: [{ name: "is_confirmed", type: "bool" }],+ });++ const event = createMockEvent();+ const contacts = [{ id: "contact-1", email: "[email protected]" }];++ await service.createEvent(event, contacts);++ const createCall = mockHubspotClient.crm.objects.meetings.basicApi.create.mock.calls[0][0];+ expect(createCall.properties.is_confirmed).toBe(true);+ });++ it("should include date field with booking start date", async () => {+ mockAppOptions({+ onBookingWriteToEventObject: true,+ onBookingWriteToEventObjectFields: {+ meeting_date: {+ fieldType: CrmFieldType.DATE,+ value: DateFieldType.BOOKING_START_DATE,+ whenToWrite: WhenToWrite.EVERY_BOOKING,+ },+ },+ });+ setupCreateEventMocks();++ mockHubspotClient.crm.properties.coreApi.getAll.mockResolvedValueOnce({+ results: [{ name: "meeting_date", type: "date" }],+ });++ const event = createMockEvent({ startTime: "2024-01-20T14:00:00.000Z" });+ const contacts = [{ id: "contact-1", email: "[email protected]" }];++ await service.createEvent(event, contacts);++ const createCall = mockHubspotClient.crm.objects.meetings.basicApi.create.mock.calls[0][0];+ expect(createCall.properties.meeting_date).toBe("2024-01-20T14:00:00.000Z");+ });++ it("should include date field with booking created date", async () => {+ mockAppOptions({+ onBookingWriteToEventObject: true,+ onBookingWriteToEventObjectFields: {+ created_date: {+ fieldType: CrmFieldType.DATE,+ value: DateFieldType.BOOKING_CREATED_DATE,+ whenToWrite: WhenToWrite.EVERY_BOOKING,+ },+ },+ });+ setupCreateEventMocks();++ mockHubspotClient.crm.properties.coreApi.getAll.mockResolvedValueOnce({+ results: [{ name: "created_date", type: "date" }],+ });++ mockBookingRepository.findBookingByUid.mockResolvedValueOnce({+ id: 1,+ uid: "booking-123",+ createdAt: new Date("2024-01-10T09:00:00.000Z"),+ });++ const event = createMockEvent();+ const contacts = [{ id: "contact-1", email: "[email protected]" }];++ await service.createEvent(event, contacts);++ const createCall = mockHubspotClient.crm.objects.meetings.basicApi.create.mock.calls[0][0];+ expect(createCall.properties.created_date).toBe("2024-01-10T09:00:00.000Z");+ });++ it("should include phone field with static value", async () => {+ mockAppOptions({+ onBookingWriteToEventObject: true,+ onBookingWriteToEventObjectFields: {+ contact_phone: {+ fieldType: CrmFieldType.PHONE,+ value: "+1234567890",+ whenToWrite: WhenToWrite.EVERY_BOOKING,+ },+ },+ });+ setupCreateEventMocks();++ mockHubspotClient.crm.properties.coreApi.getAll.mockResolvedValueOnce({+ results: [{ name: "contact_phone", type: "phone" }],+ });++ const event = createMockEvent();+ const contacts = [{ id: "contact-1", email: "[email protected]" }];++ await service.createEvent(event, contacts);++ const createCall = mockHubspotClient.crm.objects.meetings.basicApi.create.mock.calls[0][0];+ expect(createCall.properties.contact_phone).toBe("+1234567890");+ });++ it("should skip fields that do not exist on HubSpot meeting object", async () => {+ mockAppOptions({+ onBookingWriteToEventObject: true,+ onBookingWriteToEventObjectFields: {+ existing_field: {+ fieldType: CrmFieldType.TEXT,+ value: "exists",+ whenToWrite: WhenToWrite.EVERY_BOOKING,+ },+ nonexistent_field: {+ fieldType: CrmFieldType.TEXT,+ value: "does not exist",+ whenToWrite: WhenToWrite.EVERY_BOOKING,+ },+ },+ });+ setupCreateEventMocks();++ // Only return existing_field from HubSpot properties+ mockHubspotClient.crm.properties.coreApi.getAll.mockResolvedValueOnce({+ results: [{ name: "existing_field", type: "string" }],+ });++ const event = createMockEvent();+ const contacts = [{ id: "contact-1", email: "[email protected]" }];++ await service.createEvent(event, contacts);++ const createCall = mockHubspotClient.crm.objects.meetings.basicApi.create.mock.calls[0][0];+ expect(createCall.properties.existing_field).toBe("exists");+ expect(createCall.properties).not.toHaveProperty("nonexistent_field");+ });++ it("should handle multiple custom fields of different types", async () => {+ mockAppOptions({+ onBookingWriteToEventObject: true,+ onBookingWriteToEventObjectFields: {+ text_field: {+ fieldType: CrmFieldType.TEXT,+ value: "Static Text",+ whenToWrite: WhenToWrite.EVERY_BOOKING,+ },+ name_field: {+ fieldType: CrmFieldType.TEXT,+ value: "{name}",+ whenToWrite: WhenToWrite.EVERY_BOOKING,+ },+ checkbox_field: {+ fieldType: CrmFieldType.CHECKBOX,+ value: true,+ whenToWrite: WhenToWrite.EVERY_BOOKING,+ },+ date_field: {+ fieldType: CrmFieldType.DATE,+ value: DateFieldType.BOOKING_START_DATE,+ whenToWrite: WhenToWrite.EVERY_BOOKING,+ },+ },+ });+ setupCreateEventMocks();++ mockHubspotClient.crm.properties.coreApi.getAll.mockResolvedValueOnce({+ results: [+ { name: "text_field", type: "string" },+ { name: "name_field", type: "string" },+ { name: "checkbox_field", type: "bool" },+ { name: "date_field", type: "date" },+ ],+ });++ const event = createMockEvent({+ responses: { name: { label: "Name", value: "Jane Smith" } },+ startTime: "2024-02-15T10:00:00.000Z",+ });+ const contacts = [{ id: "contact-1", email: "[email protected]" }];++ await service.createEvent(event, contacts);++ const createCall = mockHubspotClient.crm.objects.meetings.basicApi.create.mock.calls[0][0];+ expect(createCall.properties.text_field).toBe("Static Text");+ expect(createCall.properties.name_field).toBe("Jane Smith");+ expect(createCall.properties.checkbox_field).toBe(true);+ expect(createCall.properties.date_field).toBe("2024-02-15T10:00:00.000Z");+ });++ it("should skip fields with unknown placeholders that cannot be resolved", async () => {+ mockAppOptions({+ onBookingWriteToEventObject: true,+ onBookingWriteToEventObjectFields: {+ unknown_field: {+ fieldType: CrmFieldType.TEXT,+ value: "{unknown_placeholder}",+ whenToWrite: WhenToWrite.EVERY_BOOKING,+ },+ },+ });+ setupCreateEventMocks();++ mockHubspotClient.crm.properties.coreApi.getAll.mockResolvedValueOnce({+ results: [{ name: "unknown_field", type: "string" }],+ });++ const event = createMockEvent({+ responses: { name: { label: "Name", value: "John" } },+ });+ const contacts = [{ id: "contact-1", email: "[email protected]" }];++ await service.createEvent(event, contacts);++ // Field with null value should be filtered out and not sent to HubSpot+ const createCall = mockHubspotClient.crm.objects.meetings.basicApi.create.mock.calls[0][0];+ expect(createCall.properties).not.toHaveProperty("unknown_field");+ });++ it("should associate meeting with contacts", async () => {+ mockAppOptions({});+ setupCreateEventMocks();++ const event = createMockEvent();+ const contacts = [+ { id: "contact-1", email: "[email protected]" },+ { id: "contact-2", email: "[email protected]" },+ ];++ await service.createEvent(event, contacts);++ expect(mockHubspotClient.crm.associations.batchApi.create).toHaveBeenCalledWith(+ "meetings",+ "contacts",+ {+ inputs: [+ { _from: { id: "meeting-123" }, to: { id: "contact-1" }, type: "meeting_event_to_contact" },+ { _from: { id: "meeting-123" }, to: { id: "contact-2" }, type: "meeting_event_to_contact" },+ ],+ }+ );+ });++ it("should set hubspot owner when organizer email matches", async () => {+ mockAppOptions({});++ // Mock owner lookup - return matching owner+ mockHubspotClient.crm.owners.ownersApi.getPage.mockResolvedValue({+ results: [{ id: "owner-123", email: "[email protected]" }],+ });++ mockHubspotClient.crm.objects.meetings.basicApi.create.mockResolvedValue({+ id: "meeting-123",+ properties: {},+ });++ mockHubspotClient.crm.associations.batchApi.create.mockResolvedValue({+ results: [],+ });++ const event = createMockEvent();+ const contacts = [{ id: "contact-1", email: "[email protected]" }];++ await service.createEvent(event, contacts);++ const createCall = mockHubspotClient.crm.objects.meetings.basicApi.create.mock.calls[0][0];+ expect(createCall.properties.hubspot_owner_id).toBe("owner-123");+ });++ it("should create meeting successfully when owner lookup fails due to missing scope", async () => {+ mockAppOptions({});++ // Mock owner lookup to fail with 403 missing scope error (simulating owners.read scope not granted)+ mockHubspotClient.crm.owners.ownersApi.getPage.mockRejectedValue({+ code: 403,+ body: {+ status: "error",+ message: "This app hasn't been granted all required scopes to make this call.",+ category: "MISSING_SCOPES",+ },+ });++ mockHubspotClient.crm.objects.meetings.basicApi.create.mockResolvedValue({+ id: "meeting-123",+ properties: {},+ });++ mockHubspotClient.crm.associations.batchApi.create.mockResolvedValue({+ results: [],+ });++ const event = createMockEvent();+ const contacts = [{ id: "contact-1", email: "[email protected]" }];++ // Should not throw and meeting should be created successfully+ const result = await service.createEvent(event, contacts);++ expect(result).toEqual({+ uid: "meeting-123",+ id: "meeting-123",+ type: "hubspot_other_calendar",+ password: "",+ url: "",+ additionalInfo: { contacts, associatedMeeting: { results: [] } },+ });++ // Verify meeting was created without owner+ const createCall = mockHubspotClient.crm.objects.meetings.basicApi.create.mock.calls[0][0];+ expect(createCall.properties.hubspot_owner_id).toBeUndefined();++ // Verify meeting creation and association still happened+ expect(mockHubspotClient.crm.objects.meetings.basicApi.create).toHaveBeenCalled();+ expect(mockHubspotClient.crm.associations.batchApi.create).toHaveBeenCalled();+ });+ });++ describe("updateEvent", () => {+ it("should update meeting with standard properties", async () => {+ mockHubspotClient.crm.objects.meetings.basicApi.update.mockResolvedValue({+ id: "meeting-123",+ properties: {},+ });++ const event = createMockEvent({+ title: "Updated Meeting",+ startTime: "2024-01-25T14:00:00.000Z",+ endTime: "2024-01-25T15:00:00.000Z",+ });++ await service.updateEvent("meeting-123", event);++ expect(mockHubspotClient.crm.objects.meetings.basicApi.update).toHaveBeenCalledWith("meeting-123", {+ properties: expect.objectContaining({+ hs_meeting_title: "Updated Meeting",+ hs_meeting_outcome: "RESCHEDULED",+ }),+ });+ });+ });++ describe("deleteEvent", () => {+ it("should cancel meeting when organizer has not changed", async () => {+ mockHubspotClient.crm.objects.meetings.basicApi.update.mockResolvedValue({+ id: "meeting-123",+ properties: {},+ });++ const event = createMockEvent({ hasOrganizerChanged: false });++ await service.deleteEvent("meeting-123", event);++ expect(mockHubspotClient.crm.objects.meetings.basicApi.update).toHaveBeenCalledWith("meeting-123", {+ properties: {+ hs_meeting_outcome: "CANCELED",+ },+ });+ });++ it("should archive meeting when organizer has changed", async () => {+ mockHubspotClient.crm.objects.meetings.basicApi.archive.mockResolvedValue(undefined);++ const event = createMockEvent({ hasOrganizerChanged: true });++ await service.deleteEvent("meeting-123", event);++ expect(mockHubspotClient.crm.objects.meetings.basicApi.archive).toHaveBeenCalledWith("meeting-123");+ });+ });+});diff --git a/packages/app-store/hubspot/lib/CrmService.ts b/packages/app-store/hubspot/lib/CrmService.tsindex a3172a4d95a..bb19809b78a 100644--- a/packages/app-store/hubspot/lib/CrmService.ts+++ b/packages/app-store/hubspot/lib/CrmService.ts@@ -14,12 +14,15 @@ import { WEBAPP_URL } from "@calcom/lib/constants";import { HttpError } from "@calcom/lib/http-error";import logger from "@calcom/lib/logger";import prisma from "@calcom/prisma";-import type { CalendarEvent } from "@calcom/types/Calendar";+import type { CalendarEvent, CalEventResponses } from "@calcom/types/Calendar";import type { CredentialPayload } from "@calcom/types/Credential";import type { CRM, ContactCreateInput, Contact, CrmEvent } from "@calcom/types/CrmService";+import { CrmFieldType, DateFieldType } from "../../_lib/crm-enums";import getAppKeysFromSlug from "../../_utils/getAppKeysFromSlug";import refreshOAuthTokens from "../../_utils/oauth/refreshOAuthTokens";+import { BookingRepository } from "@calcom/features/bookings/repositories/BookingRepository";+import { PrismaTrackingRepository } from "@calcom/lib/server/repository/PrismaTrackingRepository";import type { HubspotToken } from "../api/callback";import type { appDataSchema } from "../zod";@@ -32,6 +35,8 @@ export default class HubspotCalendarService implements CRM {private client_secret = "";private hubspotClient: hubspot.Client;private appOptions: z.infer<typeof appDataSchema>;+ private bookingRepository: BookingRepository;+ private trackingRepository: PrismaTrackingRepository;constructor(credential: CredentialPayload, appOptions?: z.infer<typeof appDataSchema>) {this.hubspotClient = new hubspot.Client();@@ -43,6 +48,8 @@ export default class HubspotCalendarService implements CRM {this.log = logger.getSubLogger({ prefix: [`[[lib] ${this.integrationName}`] });this.appOptions = appOptions || {};+ this.bookingRepository = new BookingRepository(prisma);+ this.trackingRepository = new PrismaTrackingRepository(prisma);}private getHubspotMeetingBody = (event: CalendarEvent): string => {@@ -72,7 +79,206 @@ export default class HubspotCalendarService implements CRM {`;};+ private async ensureFieldsExistOnMeeting(fieldsToTest: string[]) {+ const log = logger.getSubLogger({ prefix: [`[ensureFieldsExistOnMeeting]`] });+ const fieldSet = new Set(fieldsToTest);+ const foundFields: Array<{ name: string; type: string;[key: string]: any }> = [];++ try {+ const properties = await this.hubspotClient.crm.properties.coreApi.getAll("meetings");++ for (const property of properties.results) {+ if (foundFields.length === fieldSet.size) break;++ if (fieldSet.has(property.name)) {+ foundFields.push(property);+ }+ }++ const foundFieldNames = new Set(foundFields.map((f) => f.name));+ const missingFields = fieldsToTest.filter((field) => !foundFieldNames.has(field));++ if (missingFields.length > 0) {+ log.warn(+ `The following fields do not exist in HubSpot and will be skipped: ${missingFields.join(", ")}. Meeting creation will continue without these fields.`+ );+ }++ return foundFields;+ } catch (e: any) {+ log.error(`Error ensuring fields ${fieldsToTest} exist on Meeting object with error ${e}`);+ // Return empty array to gracefully degrade - meeting creation will proceed without custom field validation+ return [];+ }+ }++ private async getTextValueFromBookingTracking(fieldValue: string, bookingUid: string, fieldName: string) {+ const log = logger.getSubLogger({+ prefix: [`[getTextValueFromBookingTracking]: ${fieldName} - ${bookingUid}`],+ });++ const tracking = await this.trackingRepository.findByBookingUid(bookingUid);++ if (!tracking) {+ log.warn(`No tracking found for bookingUid ${bookingUid}`);+ return "";+ }++ const utmParam = fieldValue.split(":")[1].slice(0, -1);+ return tracking[`utm_${utmParam}` as keyof typeof tracking]?.toString() ?? "";+ }++ private getTextValueFromBookingResponse(fieldValue: string, calEventResponses: CalEventResponses) {+ const regexValueToReplace = /\{(.*?)\}/g;+ return fieldValue.replace(regexValueToReplace, (match, captured) => {+ return calEventResponses[captured]?.value ? calEventResponses[captured].value.toString() : match;+ });+ }++ private async getDateFieldValue(+ fieldValue: string,+ startTime?: string,+ bookingUid?: string | null+ ): Promise<string | null> {+ if (fieldValue === DateFieldType.BOOKING_START_DATE) {+ if (!startTime) {+ this.log.error("StartTime is required for BOOKING_START_DATE but was not provided");+ return null;+ }+ return new Date(startTime).toISOString();+ }++ if (fieldValue === DateFieldType.BOOKING_CREATED_DATE && bookingUid) {+ const booking = await this.bookingRepository.findBookingByUid({ bookingUid });++ if (!booking) {+ this.log.warn(`No booking found for ${bookingUid}`);+ return null;+ }++ return new Date(booking.createdAt).toISOString();+ }++ if (fieldValue === DateFieldType.BOOKING_CANCEL_DATE) {+ return new Date().toISOString();+ }++ return null;+ }++ private async getFieldValue({+ fieldValue,+ fieldType,+ calEventResponses,+ bookingUid,+ startTime,+ fieldName,+ }: {+ fieldValue: string | boolean;+ fieldType: CrmFieldType;+ calEventResponses?: CalEventResponses | null;+ bookingUid?: string | null;+ startTime?: string;+ fieldName: string;+ }): Promise<string | boolean | null> {+ const log = logger.getSubLogger({ prefix: [`[getFieldValue]: ${fieldName}`] });++ if (fieldType === CrmFieldType.CHECKBOX) {+ return !!fieldValue;+ }++ if (fieldType === CrmFieldType.DATE || fieldType === CrmFieldType.DATETIME) {+ return await this.getDateFieldValue(fieldValue as string, startTime, bookingUid);+ }++ if (+ fieldType === CrmFieldType.TEXT ||+ fieldType === CrmFieldType.STRING ||+ fieldType === CrmFieldType.PHONE ||+ fieldType === CrmFieldType.TEXTAREA ||+ fieldType === CrmFieldType.CUSTOM+ ) {+ if (typeof fieldValue !== "string") {+ log.error(`Expected string value for field ${fieldName}, got ${typeof fieldValue}`);+ return null;+ }++ if (!fieldValue.startsWith("{") && !fieldValue.endsWith("}")) {+ log.info("Returning static value");+ return fieldValue;+ }++ let valueToWrite = fieldValue;++ // Extract from UTM tracking+ if (fieldValue.startsWith("{utm:")) {+ if (!bookingUid) {+ log.error(`BookingUid not passed. Cannot get tracking values without it`);+ return null;+ }+ valueToWrite = await this.getTextValueFromBookingTracking(fieldValue, bookingUid, fieldName);+ } else {+ // Extract from booking form responses+ if (!calEventResponses) {+ log.error(`CalEventResponses not passed. Cannot get booking form responses`);+ return null;+ }+ valueToWrite = this.getTextValueFromBookingResponse(fieldValue, calEventResponses);+ }++ if (valueToWrite === fieldValue) {+ log.error("No responses found returning nothing");+ return null;+ }++ return valueToWrite;+ }++ log.error(`Unsupported field type ${fieldType} for field ${fieldName}`);+ return null;+ }++ private async generateWriteToMeetingBody(event: CalendarEvent) {+ const appOptions = this.getAppOptions();++ const customFieldInputsEnabled =+ appOptions?.onBookingWriteToEventObject && appOptions?.onBookingWriteToEventObjectFields;++ if (!customFieldInputsEnabled) return {};++ if (!appOptions?.onBookingWriteToEventObjectFields) return {};++ const customFieldInputs = customFieldInputsEnabled+ ? await this.ensureFieldsExistOnMeeting(Object.keys(appOptions.onBookingWriteToEventObjectFields))+ : [];++ const confirmedCustomFieldInputs: Record<string, any> = {};++ for (const field of customFieldInputs) {+ const fieldConfig = appOptions.onBookingWriteToEventObjectFields[field.name];++ const fieldValue = await this.getFieldValue({+ fieldValue: fieldConfig.value,+ fieldType: fieldConfig.fieldType,+ calEventResponses: event.responses,+ bookingUid: event?.uid,+ startTime: event.startTime,+ fieldName: field.name,+ });++ if (fieldValue !== null) {+ confirmedCustomFieldInputs[field.name] = fieldValue;+ }+ }++ this.log.info(`Writing to meeting fields: ${Object.keys(confirmedCustomFieldInputs)}`);++ return confirmedCustomFieldInputs;+ }+private hubspotCreateMeeting = async (event: CalendarEvent, hubspotOwnerId?: string) => {+ const writeToMeetingRecord = await this.generateWriteToMeetingBody(event);+const properties: Record<string, string> = {hs_timestamp: Date.now().toString(),hs_meeting_title: event.title,@@ -81,6 +287,7 @@ export default class HubspotCalendarService implements CRM {hs_meeting_start_time: new Date(event.startTime).toISOString(),hs_meeting_end_time: new Date(event.endTime).toISOString(),hs_meeting_outcome: "SCHEDULED",+ ...writeToMeetingRecord,};if (hubspotOwnerId) {diff --git a/packages/app-store/hubspot/zod.ts b/packages/app-store/hubspot/zod.tsindex 2e173c3143a..712d1b1bea1 100644--- a/packages/app-store/hubspot/zod.ts+++ b/packages/app-store/hubspot/zod.ts@@ -1,10 +1,16 @@import { z } from "zod";+import { writeToBookingEntry } from "../_lib/crm-schemas";import { eventTypeAppCardZod } from "../eventTypeAppCardZod";+export { writeToBookingEntry, writeToRecordEntrySchema } from "../_lib/crm-schemas";+export { CrmFieldType, WhenToWrite, DateFieldType } from "../_lib/crm-enums";+export const appDataSchema = eventTypeAppCardZod.extend({ignoreGuests: z.boolean().optional(),skipContactCreation: z.boolean().optional(),+ onBookingWriteToEventObject: z.boolean().optional(),+ onBookingWriteToEventObjectFields: z.record(z.string(), writeToBookingEntry).optional(),});export const appKeysSchema = z.object({diff --git a/packages/lib/server/repository/PrismaTrackingRepository.ts b/packages/lib/server/repository/PrismaTrackingRepository.tsnew file mode 100644index 00000000000..24b5f537d32--- /dev/null+++ b/packages/lib/server/repository/PrismaTrackingRepository.ts@@ -0,0 +1,18 @@+import type { PrismaClient } from "@calcom/prisma";+import prisma from "@calcom/prisma";++import type { TrackingRepositoryInterface } from "./TrackingRepository.interface";++export class PrismaTrackingRepository implements TrackingRepositoryInterface {+ constructor(private readonly prismaClient: PrismaClient = prisma) {}++ async findByBookingUid(bookingUid: string) {+ return await this.prismaClient.tracking.findFirst({+ where: {+ booking: {+ uid: bookingUid,+ },+ },+ });+ }+}diff --git a/packages/lib/server/repository/TrackingRepository.interface.ts b/packages/lib/server/repository/TrackingRepository.interface.tsnew file mode 100644index 00000000000..9ccebda6356--- /dev/null+++ b/packages/lib/server/repository/TrackingRepository.interface.ts@@ -0,0 +1,5 @@+import type { Tracking } from "@calcom/prisma/client";++export interface TrackingRepositoryInterface {+ findByBookingUid(bookingUid: string): Promise<Tracking | null>;+}diff --git a/packages/prisma/selects/booking.ts b/packages/prisma/selects/booking.tsindex 2cc5c8223f0..1941b881ac1 100644--- a/packages/prisma/selects/booking.ts+++ b/packages/prisma/selects/booking.ts@@ -10,6 +10,7 @@ export const bookingMinimalSelect = {endTime: true,attendees: true,metadata: true,+ createdAt: true,} satisfies Prisma.BookingSelect;export const bookingAuthorizationCheckSelect = {