Scheduling infrastructure for absolutely everyone.
test: Salesforce CRM - Add user facing tests and more logs (#19531)
Hariom Balhara381e22ae7e99
diff --git a/packages/app-store/salesforce/lib/CrmService.ts b/packages/app-store/salesforce/lib/CrmService.tsindex 3de19e886fc..90210ac2aec 100644--- a/packages/app-store/salesforce/lib/CrmService.ts+++ b/packages/app-store/salesforce/lib/CrmService.ts@@ -391,7 +391,7 @@ export default class SalesforceCRMService implements CRM {if (recordToSearch === SalesforceRecordEnum.ACCOUNT) {// For an account let's assume that the first email is the one we should be querying againstconst attendeeEmail = emailArray[0];- log.info("Searching account for email", safeStringify({ attendeeEmail }));+ log.info("[recordToSearch=ACCOUNT] Searching contact for email", safeStringify({ attendeeEmail }));soql = `SELECT Id, Email, OwnerId, AccountId, Account.Owner.Email, Account.Website FROM ${SalesforceRecordEnum.CONTACT} WHERE Email = '${attendeeEmail}' AND AccountId != null`;} else {// Handle Contact/Lead record types@@ -454,25 +454,26 @@ export default class SalesforceCRMService implements CRM {!(await this.shouldSkipAttendeeIfFreeEmailDomain(emailArray[0]));const includeAccountRecordType = forRoundRobinSkip && recordToSearch === SalesforceRecordEnum.ACCOUNT;-return records.map((record) => {+ // Handle if Account is nested+ const ownerEmail =+ recordToSearch === SalesforceRecordEnum.ACCOUNT &&+ record?.attributes?.type !== SalesforceRecordEnum.ACCOUNT+ ? record?.Account?.Owner?.Email+ : record?.Owner?.Email;+return {id: includeAccountRecordType ? record?.AccountId : record?.Id || "",email: record?.Email || "",recordType: includeAccountRecordType ? SalesforceRecordEnum.ACCOUNT : record?.attributes?.type,...(includeOwnerData && {ownerId: record?.OwnerId,- // Handle if Account is nested- ownerEmail:- recordToSearch === SalesforceRecordEnum.ACCOUNT &&- record?.attributes?.type !== SalesforceRecordEnum.ACCOUNT- ? record?.Account?.Owner?.Email- : record?.Owner?.Email,+ ownerEmail: ownerEmail,}),};});} catch (error) {- log.error("Error in getContacts", safeStringify({ error }));+ log.error("Error in getContacts", safeStringify(error));return [];}}@@ -482,7 +483,7 @@ export default class SalesforceCRMService implements CRM {organizerEmail?: string,calEventResponses?: CalEventResponses | null) {- const log = logger.getSubLogger({ prefix: [`[getContacts]`] });+ const log = logger.getSubLogger({ prefix: [`[createContacts]`] });const conn = await this.conn;const appOptions = this.getAppOptions();const createEventOn = appOptions.createEventOn ?? SalesforceRecordEnum.CONTACT;@@ -901,13 +902,15 @@ export default class SalesforceCRMService implements CRM {private async getAccountBasedOnEmailDomainOfContacts(email: string) {const conn = await this.conn;const emailDomain = email.split("@")[1];-+ const log = logger.getSubLogger({ prefix: [`[getAccountBasedOnEmailDomainOfContacts]:${email}`] });+ log.info("Querying first account matching email domain", safeStringify({ emailDomain }));// First check if an account has the same website as the email domain of the attendeeconst accountQuery = await conn.query(`SELECT Id, OwnerId, Owner.Email FROM Account WHERE Website LIKE '%${emailDomain}%' LIMIT 1`);if (accountQuery.records.length > 0) {+ log.info("Found account matching email domain", safeStringify({ emailDomain }));return {...(accountQuery.records[0] as { Id?: string; OwnerId?: string; Owner?: { Email?: string } }),Email: undefined,@@ -928,6 +931,7 @@ export default class SalesforceCRMService implements CRM {const dominantAccountId = this.getDominantAccountId(contacts);const contactUnderAccount = contacts.find((contact) => contact.AccountId === dominantAccountId);+ log.info("Using dominant account's owner", safeStringify({ dominantAccountId }));return {Id: dominantAccountId,diff --git a/packages/app-store/salesforce/lib/__tests__/CrmService.integration.test.ts b/packages/app-store/salesforce/lib/__tests__/CrmService.integration.test.tsnew file mode 100644index 00000000000..0e98fc451d5--- /dev/null+++ b/packages/app-store/salesforce/lib/__tests__/CrmService.integration.test.ts@@ -0,0 +1,340 @@+/**+ * Purpose of these tests is to ensure that we test from CrmService and salesforce interactions perspective purely+ * It allows us to document the behaviour more from User perspective and also verify it in parallel+ *+ * It will also give us confidence to refactor as it doesn't care about internal functions.+ *+ * CrmService.test.ts could still focus on testing detailed edge cases as needed.+ */+import "../../../../../tests/libs/__mocks__/prisma";++import jsforce from "@jsforce/jsforce-node";+import { describe, it, expect, vi, beforeEach } from "vitest";++import SalesforceCRMService from "../CrmService";+import { SalesforceRecordEnum } from "../enums";+import { createSalesforceMock } from "./salesforceMock";++vi.mock("@calcom/lib/constants", () => {+ return {+ WEBAPP_URL: "https://app.cal.com",+ APP_CREDENTIAL_SHARING_ENABLED: false,+ IS_PRODUCTION: false,+ };+});+// Mock dependencies+vi.mock("@jsforce/jsforce-node", () => {+ return {+ default: {+ Connection: vi.fn().mockImplementation(() => ({})),+ },+ };+});++vi.mock("@calcom/lib/freeEmailDomainCheck/checkIfFreeEmailDomain", () => ({+ checkIfFreeEmailDomain: vi.fn().mockResolvedValue(false),+}));++vi.mock("../getSalesforceAppKeys", () => ({+ getSalesforceAppKeys: vi.fn().mockResolvedValue({+ consumer_key: "test_consumer_key",+ consumer_secret: "test_consumer_secret",+ }),+}));++// Helper to create mock credential+const createMockCredential = () => {+ return {+ id: 1,+ key: {+ access_token: "test_access_token",+ refresh_token: "test_refresh_token",+ instance_url: "https://test.salesforce.com",+ },+ type: "salesforce_other_calendar",+ user: {+ email: "[email protected]",+ },+ userId: 1,+ teamId: 1,+ appId: "test_app_id",+ invalid: false,+ };+};++const salesforceSettingScenario = {+ createOnLeadAndSearchOnAccount: () => {+ return {+ appOptions: {+ createEventOn: SalesforceRecordEnum.LEAD,+ createEventOnLeadCheckForContact: true,+ roundRobinSkipCheckRecordOn: SalesforceRecordEnum.ACCOUNT,+ },+ credential: createMockCredential(),+ };+ },+};++describe("SalesforceCRMService", () => {+ let salesforceMock: ReturnType<typeof createSalesforceMock>;++ beforeEach(() => {+ salesforceMock = createSalesforceMock();+ fetchMock.mockReturnValueOnce(+ Promise.resolve(+ new Response(+ JSON.stringify({+ id: "abc",+ issued_at: "123",+ instance_url: "https://test.salesforce.com",+ signature: "123",+ access_token: "123",+ scope: "123",+ token_type: "123",+ }),+ {+ status: 200,+ }+ )+ )+ );+ // Override jsforce mock with our custom mock+ // @ts-expect-error - Not full implementation of jsforce.Connection+ vi.mocked(jsforce.Connection).mockImplementation(() => ({+ ...salesforceMock.mockConnection,+ version: "1.0",+ loginUrl: "https://test.salesforce.com",+ instanceUrl: "https://test.salesforce.com",+ accessToken: "123",+ }));+ });++ describe("createOnLeadAndSearchOnAccount", () => {+ const { appOptions, credential } = salesforceSettingScenario.createOnLeadAndSearchOnAccount();+ describe("getContacts: forRoundRobinSkip=true", () => {+ const forRoundRobinSkip = true;+ it("(Lookup-1) should return contact's account owner's email as ownerEmail if the contact is found directly by email", async () => {+ const crmService = new SalesforceCRMService(credential, appOptions);+ const contactAccountOwnerEmail = "[email protected]";+ const contactOwnerEmail = "[email protected]";+ const lookingForEmail = "[email protected]";++ const account = salesforceMock.addAccount({+ Id: "test-account-id",+ Owner: {+ Email: contactAccountOwnerEmail,+ },+ Website: "https://anything",+ });++ salesforceMock.addContact({+ Email: lookingForEmail,+ FirstName: "Test",+ LastName: "User",+ AccountId: account.Id,+ Owner: {+ Email: contactOwnerEmail,+ },+ });++ const contacts = await crmService.getContacts({+ emails: lookingForEmail,+ forRoundRobinSkip,+ });++ expect(contacts).toHaveLength(1);+ expect(contacts[0].ownerEmail).toBe(contactAccountOwnerEmail);+ expect(contacts[0].email).toBe(lookingForEmail);+ expect(contacts[0].recordType).toBe(SalesforceRecordEnum.ACCOUNT);+ expect(contacts[0].id).toBe(account.Id);+ });++ it("(Lookup-2) should fallback to account(and use the account owner email as ownerEmail) matched by emailDomain if the contact is not found(i.e Lookup-1 fails)", async () => {+ const crmService = new SalesforceCRMService(credential, appOptions);+ const contactAccountOwnerEmail = "[email protected]";+ const emailDomain = "example.com";+ const lookingForEmail = `test@${emailDomain}`;+ const account = salesforceMock.addAccount({+ Id: "test-account-id",+ Owner: {+ Email: contactAccountOwnerEmail,+ },+ Website: `https://${emailDomain}`,+ });++ const contacts = await crmService.getContacts({+ emails: lookingForEmail,+ forRoundRobinSkip,+ });++ expect(contacts).toHaveLength(1);+ expect(contacts[0].ownerEmail).toBe(contactAccountOwnerEmail);+ // Account doesn't have email+ expect(contacts[0].email).toBe("");+ expect(contacts[0].recordType).toBe(SalesforceRecordEnum.ACCOUNT);+ // FIXME: Seems like a bug as this should have been accountId but it is undefined+ // expect(contacts[0].id).toBe(account.Id);+ });++ it("(Lookup-3) should fallback to account having most number of contacts matched by emailDomain when Lookup-1 and Lookup-2 fails", async () => {+ const crmService = new SalesforceCRMService(credential, appOptions);+ const account1OwnerEmail = "[email protected]";+ const account2OwnerEmail = "[email protected]";+ const emailDomain = "example.com";+ const lookingForEmail = `test@${emailDomain}`;+ const account1 = salesforceMock.addAccount({+ Id: "test-account-id1",+ Owner: {+ Email: account1OwnerEmail,+ },+ Website: `https://anything`,+ });++ const dominatingAccount = salesforceMock.addAccount({+ Id: "test-account-id2",+ Owner: {+ Email: account2OwnerEmail,+ },+ Website: `https://anything`,+ });++ salesforceMock.addContact({+ Email: `some-other-contact_acc2_1@${emailDomain}`,+ FirstName: "Test",+ LastName: "User",+ AccountId: dominatingAccount.Id,+ });++ salesforceMock.addContact({+ Email: `some-other-contact_acc2_2@${emailDomain}`,+ FirstName: "Test",+ LastName: "User",+ AccountId: dominatingAccount.Id,+ });++ salesforceMock.addContact({+ Email: `some-other-contact_acc1_1@${emailDomain}`,+ FirstName: "Test",+ LastName: "User",+ AccountId: account1.Id,+ });++ const contacts = await crmService.getContacts({+ emails: lookingForEmail,+ forRoundRobinSkip,+ });++ expect(contacts).toHaveLength(1);+ expect(contacts[0].ownerEmail).toBe(account2OwnerEmail);+ // Account doesn't have email+ expect(contacts[0].email).toBe("");+ expect(contacts[0].recordType).toBe(SalesforceRecordEnum.ACCOUNT);+ // FIXME: Seems like a bug as this should have been accountId but it is undefined+ // expect(contacts[0].id).toBe(dominatingAccount.Id);+ });+ });++ describe("getContacts: forRoundRobinSkip=false i.e. how it is called when creating event", () => {+ const forRoundRobinSkip = false;+ it("should return lead object if the lead is found directly by email and contact is not found by that email", async () => {+ const crmService = new SalesforceCRMService(credential, appOptions);+ const contactAccountOwnerEmail = "[email protected]";+ const contactOwnerEmail = "[email protected]";+ const leadOwnerEmail = "[email protected]";+ const lookingForEmail = "[email protected]";+ const contactEmail = "[email protected]";++ const account = salesforceMock.addAccount({+ Id: "test-account-id",+ Owner: {+ Email: contactAccountOwnerEmail,+ },+ Website: "https://anything",+ });++ const contact = salesforceMock.addContact({+ // Contact doesn't have the matching email+ Email: contactEmail,+ FirstName: "Test",+ LastName: "User",+ AccountId: account.Id,+ Owner: {+ Email: contactOwnerEmail,+ },+ });++ const lead = salesforceMock.addLead({+ // Lead has the matching email+ Email: lookingForEmail,+ FirstName: "Test",+ LastName: "User",+ Owner: {+ Email: leadOwnerEmail,+ },+ });++ const contactsOrLeadsOrAccounts = await crmService.getContacts({+ emails: lookingForEmail,+ forRoundRobinSkip,+ });++ expect(contactsOrLeadsOrAccounts).toHaveLength(1);+ // Because we intentionally don't include owner data in this case+ expect(contactsOrLeadsOrAccounts[0].ownerEmail).toBe(undefined);+ expect(contactsOrLeadsOrAccounts[0].email).toBe(lookingForEmail);+ expect(contactsOrLeadsOrAccounts[0].recordType).toBe(SalesforceRecordEnum.LEAD);+ expect(contactsOrLeadsOrAccounts[0].id).toBe(lead.Id);+ });++ it("should return contact object(if there is one by that email) even if lead is found by that email", async () => {+ const crmService = new SalesforceCRMService(credential, appOptions);+ const contactAccountOwnerEmail = "[email protected]";+ const contactOwnerEmail = "[email protected]";+ const leadOwnerEmail = "[email protected]";+ const lookingForEmail = "[email protected]";+ const contactEmail = "[email protected]";++ const account = salesforceMock.addAccount({+ Id: "test-account-id",+ Owner: {+ Email: contactAccountOwnerEmail,+ },+ Website: "https://anything",+ });++ const contact = salesforceMock.addContact({+ // Contact doesn't have the matching email+ Email: lookingForEmail,+ FirstName: "Test",+ LastName: "User",+ AccountId: account.Id,+ Owner: {+ Email: contactOwnerEmail,+ },+ });++ const lead = salesforceMock.addLead({+ // Lead has the matching email+ Email: lookingForEmail,+ FirstName: "Test",+ LastName: "User",+ Owner: {+ Email: leadOwnerEmail,+ },+ });++ const contactsOrLeadsOrAccounts = await crmService.getContacts({+ emails: lookingForEmail,+ forRoundRobinSkip,+ });++ expect(contactsOrLeadsOrAccounts).toHaveLength(1);+ // Because we intentionally don't include owner data in this case+ expect(contactsOrLeadsOrAccounts[0].ownerEmail).toBe(undefined);+ expect(contactsOrLeadsOrAccounts[0].id).toBe(contact.Id);+ expect(contactsOrLeadsOrAccounts[0].email).toBe(lookingForEmail);+ expect(contactsOrLeadsOrAccounts[0].recordType).toBe(SalesforceRecordEnum.CONTACT);+ });+ });+ });+});diff --git a/packages/app-store/salesforce/lib/__tests__/salesforceMock.ts b/packages/app-store/salesforce/lib/__tests__/salesforceMock.tsnew file mode 100644index 00000000000..63bcf63ce0a--- /dev/null+++ b/packages/app-store/salesforce/lib/__tests__/salesforceMock.ts@@ -0,0 +1,294 @@+import { vi } from "vitest";++import logger from "@calcom/lib/logger";+import { safeStringify } from "@calcom/lib/safeStringify";++type Contact = {+ Id?: string;+ FirstName?: string;+ LastName?: string;+ Email?: string;+ AccountId?: string;+ Account?: Account;+ Owner?: {+ Email?: string;+ };+ OwnerId?: string;+};+type Lead = {+ Id?: string;+ FirstName?: string;+ LastName?: string;+ Email?: string;+ AccountId?: string;+ Account?: Account;+ Owner?: {+ Email?: string;+ };+ OwnerId?: string;+};+type Account = { Id?: string; OwnerId?: string; Owner?: { Email?: string }; Website?: string };+type User = { Id?: string; IsActive?: boolean; Email?: string };++// Salesforce mock factory+export const createSalesforceMock = () => {+ // Store for mock records+ const records = {+ contacts: [] as Contact[],+ leads: [] as Lead[],+ accounts: [] as Account[],+ users: [] as User[],+ // eslint-disable-next-line @typescript-eslint/no-explicit-any+ events: [] as any[],+ };++ // Query parser and responder+ const handleQuery = (query: string) => {+ // Simple SOQL parser+ const fromMatch = query.match(/FROM\s+(\w+)/i);+ const whereMatch = query.match(/WHERE\s+(.+?)(?:\s+LIMIT|\s+ORDER|\s*$)/i);+ const limitMatch = query.match(/LIMIT\s+(\d+)/i);++ if (!fromMatch) return { records: [] };++ const objectType = fromMatch[1];+ const whereClause = whereMatch ? whereMatch[1] : null;+ const limit = limitMatch ? parseInt(limitMatch[1]) : Infinity;++ let result = [];++ switch (objectType) {+ case "Contact":+ result = records.contacts;+ break;+ case "Lead":+ result = records.leads;+ break;+ case "Account":+ result = records.accounts;+ break;+ case "User":+ result = records.users;+ break;+ case "Event":+ result = records.events;+ break;+ default:+ return { records: [] };+ }++ // Apply where clause filtering (basic implementation)+ if (whereClause) {+ if (whereClause.includes("Email =")) {+ const emailMatch = whereClause.match(/Email\s*=\s*'([^']+)'/i);+ if (emailMatch) {+ const email = emailMatch[1];+ result = result.filter((r) => r.Email === email);+ }+ }++ if (whereClause.includes("Email IN")) {+ const emailsMatch = whereClause.match(/Email IN \('([^']+)(?:','([^']+))*'\)/i);+ if (emailsMatch) {+ const emails = whereClause+ .match(/Email IN \((.+)\)/i)?.[1]+ ?.split("','")+ ?.map((e) => e.replace(/'/g, ""));+ result = result.filter((r) => emails?.includes(r.Email));+ }+ }++ if (whereClause.includes("Email LIKE")) {+ const emailLikeMatch = whereClause.match(/Email LIKE '%@([^']+)'/i);+ if (emailLikeMatch) {+ const domain = emailLikeMatch[1];+ result = result.filter((r) => r.Email && r.Email.endsWith(`@${domain}`));+ }+ }++ if (whereClause.includes("Id =")) {+ const idMatch = whereClause.match(/Id\s*=\s*'([^']+)'/i);+ if (idMatch) {+ const id = idMatch[1];+ result = result.filter((r) => r.Id === id);+ }+ }++ if (whereClause.includes("AccountId =")) {+ const accountIdMatch = whereClause.match(/AccountId\s*=\s*'([^']+)'/i);+ if (accountIdMatch) {+ const accountId = accountIdMatch[1];+ result = result.filter((r) => r.AccountId === accountId);+ }+ }++ if (whereClause.includes("AccountId != null")) {+ result = result.filter((r) => r.AccountId);+ }++ if (whereClause.includes("Website LIKE")) {+ const websiteLikeMatch = whereClause.match(/Website LIKE '%([^']+)%'/i);+ if (websiteLikeMatch) {+ const websitePart = websiteLikeMatch[1];+ result = result.filter((r) => r.Website && r.Website.includes(websitePart));+ }+ }++ if (whereClause.includes("IsActive = true")) {+ result = result.filter((r) => r.IsActive === true);+ }+ }++ // Apply limit+ result = result.slice(0, limit);++ // Handle special cases with nested property selection+ if (query.includes("Account.Owner.Email")) {+ result = result.map((r) => {+ if (r.AccountId) {+ const account = records.accounts.find((a) => a.Id === r.AccountId);+ if (account && account.OwnerId) {+ const owner = records.users.find((u) => u.Id === account.OwnerId);+ r.Account = {+ Owner: {+ Email: owner ? owner.Email : null,+ },+ OwnerId: account.OwnerId,+ };+ }+ }+ return r;+ });+ }++ if (query.includes("Owner.Email")) {+ result = result.map((r) => {+ if (r.OwnerId) {+ const owner = records.users.find((u) => u.Id === r.OwnerId);+ r.Owner = {+ Email: owner ? owner.Email : null,+ };+ }+ return r;+ });+ }++ return { records: result };+ };++ const getAccountById = (id: string) => {+ return records.accounts.find((a) => a.Id === id);+ };++ // Add record helpers+ const addContact = (contact: Contact) => {+ const newContact = {+ Id: contact.Id || `003${Math.random().toString().slice(2, 10)}`,+ attributes: { type: "Contact" },+ ...contact,+ };++ if (newContact.AccountId) {+ const account = getAccountById(newContact.AccountId);+ if (account) {+ newContact.Account = {+ ...account,+ };+ } else {+ throw new Error(`Account with id ${newContact.AccountId} not found`);+ }+ }++ logger.debug("[SalesforceMock]Adding contact", safeStringify(newContact));+ records.contacts.push(newContact);+ return newContact;+ };++ const addLead = (lead: Lead) => {+ const newLead = {+ Id: lead.Id || `00Q${Math.random().toString().slice(2, 10)}`,+ attributes: { type: "Lead" },+ ...lead,+ };+ if (newLead.AccountId) {+ const account = getAccountById(newLead.AccountId);+ if (account) {+ newLead.Account = {+ ...account,+ };+ } else {+ throw new Error(`Account with id ${newLead.AccountId} not found`);+ }+ }+ logger.debug("[SalesforceMock] Adding lead", safeStringify(newLead));+ records.leads.push(newLead);+ return newLead;+ };++ const addAccount = (account: Account) => {+ const newAccount = {+ Id: account.Id || `001${Math.random().toString().slice(2, 10)}`,+ ...account,+ attributes: { type: "Account" },+ };+ records.accounts.push(newAccount);+ logger.debug("[SalesforceMock] Adding account", safeStringify(newAccount));+ return newAccount;+ };++ const addUser = (user: User) => {+ const newUser = {+ Id: user.Id || `005${Math.random().toString().slice(2, 10)}`,+ IsActive: user.IsActive !== undefined ? user.IsActive : true,+ attributes: { type: "User" },+ ...user,+ };+ logger.debug("[SalesforceMock] Adding user", safeStringify(newUser));+ records.users.push(newUser);+ return newUser;+ };++ // Mock connection interface+ const mockConnection = {+ query: vi.fn().mockImplementation(handleQuery),+ sobject: vi.fn().mockReturnValue({+ create: vi.fn().mockImplementation(() => ({ success: true, id: `id_${Math.random()}` })),+ update: vi.fn().mockImplementation(() => ({ success: true })),+ delete: vi.fn().mockImplementation(() => ({ success: true })),+ }),+ describe: vi.fn().mockImplementation(() => {+ return {+ fields: [+ { name: "Id", type: "id" },+ { name: "Email", type: "email" },+ { name: "FirstName", type: "string" },+ { name: "LastName", type: "string" },+ { name: "Company", type: "string" },+ { name: "Website", type: "url" },+ { name: "OwnerId", type: "reference" },+ { name: "NoShow__c", type: "boolean", length: 0 },+ { name: "LastMeetingDate__c", type: "date" },+ ],+ };+ }),+ clear: () => {+ records.contacts = [];+ records.leads = [];+ records.accounts = [];+ records.users = [];+ records.events = [];+ mockConnection.query.mockClear();+ mockConnection.sobject.mockClear();+ mockConnection.describe.mockClear();+ },+ };++ return {+ mockConnection,+ addContact,+ addLead,+ addAccount,+ addUser,+ getRecords: () => records,+ };+};diff --git a/packages/lib/server/getTeamMemberEmailFromCrm.ts b/packages/lib/server/getTeamMemberEmailFromCrm.tsindex 3972db7393a..7ca3ac4837c 100644--- a/packages/lib/server/getTeamMemberEmailFromCrm.ts+++ b/packages/lib/server/getTeamMemberEmailFromCrm.ts@@ -123,7 +123,12 @@ async function getOwnerEmailFromCrm(if (!crmContactOwner?.email) return returnNullValue;log.info("[getOwnerEmailFromCrm] crmContactOwner",- safeStringify({ contactOwnerEmail: crmContactOwner.email, email, eventTypeId: eventData.id })+ safeStringify({+ contactOwnerEmail: crmContactOwner.email,+ recordType: crmContactOwner.recordType,+ email,+ eventTypeId: eventData.id,+ }));// Determine if the contactOwner is a part of the event typeconst contactOwnerQuery = await findUserByEmailWhoIsAHostOfEventType({