Scheduling infrastructure for absolutely everyone.
feat: Create Integration Attribute Sync records (#26007)
Joe Au-Yeung8dbe3848e713
diff --git a/apps/web/app/(use-page-wrapper)/settings/(settings-layout)/organizations/(org-admin-only)/attributes/sync/page.tsx b/apps/web/app/(use-page-wrapper)/settings/(settings-layout)/organizations/(org-admin-only)/attributes/sync/page.tsxnew file mode 100644index 00000000000..a43c7512a8f--- /dev/null+++ b/apps/web/app/(use-page-wrapper)/settings/(settings-layout)/organizations/(org-admin-only)/attributes/sync/page.tsx@@ -0,0 +1,62 @@+import { _generateMetadata, getTranslate } from "app/_utils";++import IntegrationAttributeSyncView from "@calcom/features/ee/integration-attribute-sync/IntegrationAttributeSyncView";+import { getIntegrationAttributeSyncService } from "@calcom/features/ee/integration-attribute-sync/di/IntegrationAttributeSyncService.container";+import { TeamRepository } from "@calcom/features/ee/teams/repositories/TeamRepository";+import SettingsHeader from "@calcom/features/settings/appDir/SettingsHeader";+import { PrismaAttributeRepository } from "@calcom/features/attributes/repositories/PrismaAttributeRepository";+import { prisma } from "@calcom/prisma";++import { validateUserHasOrgPerms } from "../../../actions/validateUserHasOrgPerms";++export const generateMetadata = async () =>+ await _generateMetadata(+ (t) => t("attribute_sync"),+ (t) => t("attribute_sync_description"),+ undefined,+ undefined,+ "/settings/organizations/attributes/sync"+ );++const Page = async () => {+ const t = await getTranslate();++ const session = await validateUserHasOrgPerms({+ permission: "organization.attributes.create",+ fallbackRoles: ["ADMIN", "OWNER"],+ redirectTo: "/settings/my-account/profile",+ });++ const organizationId = session.user.org.id;++ const integrationAttributeSyncService = getIntegrationAttributeSyncService();+ const teamRepository = new TeamRepository(prisma);+ const attributeRepo = new PrismaAttributeRepository(prisma);++ const [credentialData, integrationAttributeSyncs, organizationTeams, attributes] = await Promise.all([+ integrationAttributeSyncService.getEnabledAppCredentials(organizationId),+ integrationAttributeSyncService.getAllIntegrationAttributeSyncs(organizationId),+ teamRepository.findAllByParentId({+ parentId: organizationId,+ select: {+ id: true,+ name: true,+ },+ }),+ attributeRepo.findAllByOrgIdWithOptions({ orgId: organizationId }),+ ]);++ return (+ <SettingsHeader title={t("attribute_sync")} description={t("attribute_sync_description")}>+ <IntegrationAttributeSyncView+ credentialsData={credentialData}+ initialIntegrationAttributeSyncs={integrationAttributeSyncs}+ organizationTeams={organizationTeams}+ attributes={attributes}+ organizationId={organizationId}+ />+ </SettingsHeader>+ );+};++export default Page;diff --git a/apps/web/pages/api/trpc/attributeSync/[trpc].ts b/apps/web/pages/api/trpc/attributeSync/[trpc].tsnew file mode 100644index 00000000000..c679db12277--- /dev/null+++ b/apps/web/pages/api/trpc/attributeSync/[trpc].ts@@ -0,0 +1,4 @@+import { createNextApiHandler } from "@calcom/trpc/server/createNextApiHandler";+import { attributeSyncRouter } from "@calcom/trpc/server/routers/viewer/attribute-sync/_router";++export default createNextApiHandler(attributeSyncRouter);diff --git a/apps/web/public/static/locales/en/common.json b/apps/web/public/static/locales/en/common.jsonindex fbe5b15f970..1a7aa927460 100644--- a/apps/web/public/static/locales/en/common.json+++ b/apps/web/public/static/locales/en/common.json@@ -374,6 +374,7 @@"done": "Done","all_done": "All done!","all": "All",+ "any": "Any","yours": "Your account","available_apps": "Available Apps","available_apps_lower_case": "Available apps",@@ -3101,6 +3102,47 @@"back_to_attributes": "Back to attributes","delete_attribute": "Are you sure you want to delete this option?","delete_attribute_description": "This option is assigned to {{numberOfUsers}} members. Deleting it will remove it from their profile.",+ "attribute_sync": "Attribute Sync",+ "attribute_sync_description": "Setup attribute syncing with 3rd party integrations",+ "attribute_sync_new_integration_sync": "New Integration Sync",+ "attribute_sync_credential": "Credential",+ "attribute_sync_credential_required": "Credential is required",+ "attribute_sync_credential_validation": "Select a credential for the attribute sync",+ "attribute_sync_select_credential": "Select a credential...",+ "attribute_sync_credential_description": "Choose which integration credential to use for syncing attributes",+ "attribute_sync_user_filter_rules": "User Filter Rules",+ "attribute_sync_user_filter_rules_description": "Define which users to sync based on team membership or attributes",+ "attribute_sync_field_mappings": "Field Mappings",+ "attribute_sync_duplicate_field_mapping": "Duplicate field name and attribute combination found",+ "attribute_sync_duplicate_attribute_mapping": "Each attribute can only be mapped once",+ "attribute_sync_field_mappings_description": "Map integration field names to Cal.com attributes for syncing",+ "attribute_sync_created_successfully": "Attribute sync created successfully",+ "attribute_sync_updated_successfully": "Attribute sync updated successfully",+ "attribute_sync_deleted_successfully": "Attribute sync deleted successfully",+ "attribute_sync_delete_title": "Delete Attribute Sync",+ "attribute_sync_delete_confirmation": "Are you sure you want to delete this sync? This action cannot be undone.",+ "attribute_sync_no_mappings": "No field mappings added. Click below to add your first mapping.",+ "attribute_sync_add_mapping": "Add mapping",+ "attribute_sync_field_placeholder": "e.g., Department, Title...",+ "attribute_sync_select_attribute": "Select Cal.com attribute...",+ "attribute_sync_add_new": "Add new sync",+ "attribute_sync_select_teams": "Select team(s)...",+ "attribute_sync_select_attribute_first": "Select an attribute first",+ "attribute_sync_select_values": "Select value(s)...",+ "attribute_sync_enter_text_value": "Enter text value...",+ "attribute_sync_enter_number_value": "Enter number value...",+ "attribute_sync_sync_users_where": "Sync users where",+ "attribute_sync_conditions_match": "conditions match:",+ "attribute_sync_no_conditions": "No conditions added. Click below to add your first condition.",+ "attribute_sync_add_condition": "Add condition",+ "attribute_sync_operator_is_any_of": "is any of",+ "attribute_sync_operator_is_not_any_of": "is not any of",+ "attribute_sync_operator_is": "is",+ "attribute_sync_operator_is_not": "is not",+ "attribute_sync_operator_includes_any_of": "includes any of",+ "attribute_sync_operator_does_not_include": "does not include",+ "attribute_sync_operator_equals": "equals",+ "attribute_sync_operator_not_equals": "not equals","disable_all_emails_to_attendees": "Disable standard emails to attendees related to this event type","disable_all_emails_description": "Disables standard email communication related to this event type, including booking confirmations, reminders, and cancellations.","disable_all_emails_to_hosts": "Disable standard emails to hosts related to this event type",diff --git a/packages/features/credentials/repositories/CredentialRepository.ts b/packages/features/credentials/repositories/CredentialRepository.tsindex e4f4ab4eadf..ed06ee2e8cc 100644--- a/packages/features/credentials/repositories/CredentialRepository.ts+++ b/packages/features/credentials/repositories/CredentialRepository.ts@@ -300,4 +300,33 @@ export class CredentialRepository {},});}++ findByTeamIdAndSlugs({ teamId, slugs }: { teamId: number; slugs: string[] }) {+ return this.primaClient.credential.findMany({+ where: {+ teamId,+ appId: {+ in: slugs,+ },+ },+ select: { ...safeCredentialSelect, team: { select: { name: true } } },+ });+ }++ findByIdAndTeamId({ id, teamId }: { id: number; teamId: number }) {+ return this.primaClient.credential.findFirst({+ where: {+ id,+ teamId,+ },+ select: {+ ...safeCredentialSelect,+ app: {+ select: {+ slug: true,+ },+ },+ },+ });+ }}diff --git a/packages/features/ee/integration-attribute-sync/IntegrationAttributeSyncView.tsx b/packages/features/ee/integration-attribute-sync/IntegrationAttributeSyncView.tsxnew file mode 100644index 00000000000..89afb4982bb--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/IntegrationAttributeSyncView.tsx@@ -0,0 +1,106 @@+"use client";++import { useState } from "react";++import { useLocale } from "@calcom/lib/hooks/useLocale";+import type { Attribute } from "@calcom/app-store/routing-forms/types/types";+import { trpc } from "@calcom/trpc/react";+import { Button } from "@calcom/ui/components/button";++import EditIntegrationAttributeSyncCard from "./components/EditIntegrationAttributeSyncCard";+import NewIntegrationAttributeSyncCard from "./components/NewIntegrationAttributeSyncCard";+import type { IntegrationAttributeSync } from "./repositories/IIntegrationAttributeSyncRepository";++interface IIntegrationAttributeSyncViewProps {+ credentialsData: {+ id: number;+ type: string;+ team: {+ name: string;+ } | null;+ }[];+ initialIntegrationAttributeSyncs: IntegrationAttributeSync[];+ organizationTeams: {+ id: number;+ name: string;+ }[];+ attributes: Attribute[];+ organizationId: number;+}++const IntegrationAttributeSyncView = (props: IIntegrationAttributeSyncViewProps) => {+ const { credentialsData, initialIntegrationAttributeSyncs, organizationTeams, attributes, organizationId } =+ props;+ const { t } = useLocale();++ const [showNewSync, setShowNewSync] = useState(false);++ const { data: integrationAttributeSyncs } = trpc.viewer.attributeSync.getAllAttributeSyncs.useQuery(+ {},+ {+ initialData: initialIntegrationAttributeSyncs,+ }+ );++ const credentialOptions =+ credentialsData?.map((cred) => ({+ value: String(cred.id),+ label: `${cred.type} ${cred.team?.name ? `(${cred.team.name})` : ""}`,+ })) ?? [];++ const teamOptions =+ organizationTeams?.map((team) => ({+ value: String(team.id),+ label: team.name,+ })) ?? [];++ const attributeOptions =+ attributes?.map((attr) => ({+ value: attr.id,+ label: attr.name,+ })) ?? [];++ const handleAddNewSync = () => {+ setShowNewSync(true);+ };++ const handleCancel = () => {+ setShowNewSync(false);+ };++ return (+ <>+ {integrationAttributeSyncs && integrationAttributeSyncs.length > 0 && (+ <div className="mb-4 space-y-2">+ {integrationAttributeSyncs.map((sync) => (+ <EditIntegrationAttributeSyncCard+ key={sync.id}+ sync={sync}+ credentialOptions={credentialOptions}+ teamOptions={teamOptions}+ attributes={attributes}+ attributeOptions={attributeOptions}+ organizationId={organizationId}+ />+ ))}+ </div>+ )}++ {showNewSync && (+ <NewIntegrationAttributeSyncCard+ credentialOptions={credentialOptions}+ teamOptions={teamOptions}+ attributes={attributes}+ attributeOptions={attributeOptions}+ organizationId={organizationId}+ onCancel={handleCancel}+ />+ )}+ <Button StartIcon="plus" onClick={handleAddNewSync}>+ {t("attribute_sync_add_new")}+ </Button>+ </>+ );+};++export default IntegrationAttributeSyncView;diff --git a/packages/features/ee/integration-attribute-sync/components/EditIntegrationAttributeSyncCard.tsx b/packages/features/ee/integration-attribute-sync/components/EditIntegrationAttributeSyncCard.tsxnew file mode 100644index 00000000000..0a5f2b90fc9--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/components/EditIntegrationAttributeSyncCard.tsx@@ -0,0 +1,57 @@+import { useLocale } from "@calcom/lib/hooks/useLocale";+import { trpc } from "@calcom/trpc/react";+import { showToast } from "@calcom/ui/components/toast";++import type { IntegrationAttributeSync, ISyncFormData } from "../repositories/IIntegrationAttributeSyncRepository";+import IntegrationAttributeSyncCard from "./IntegrationAttributeSyncCard";+import type { IIntegrationAttributeSyncCardProps } from "./IntegrationAttributeSyncCard";++type IEditIntegrationAttributeSyncCardProps = Pick<+ IIntegrationAttributeSyncCardProps,+ "credentialOptions" | "teamOptions" | "attributes" | "organizationId" | "attributeOptions"+> & {+ sync: IntegrationAttributeSync;+};++const EditIntegrationAttributeSyncCard = (props: IEditIntegrationAttributeSyncCardProps) => {+ const { t } = useLocale();+ const utils = trpc.useUtils();+ const updateMutation = trpc.viewer.attributeSync.updateAttributeSync.useMutation({+ onSuccess: () => {+ utils.viewer.attributeSync.getAllAttributeSyncs.invalidate();+ showToast(t("attribute_sync_updated_successfully"), "success");+ },+ onError: (error) => {+ showToast(error.message, "error");+ },+ });++ const deleteMutation = trpc.viewer.attributeSync.deleteAttributeSync.useMutation({+ onSuccess: () => {+ utils.viewer.attributeSync.getAllAttributeSyncs.invalidate();+ showToast(t("attribute_sync_deleted_successfully"), "success");+ },+ onError: (error) => {+ showToast(error.message, "error");+ },+ });++ const onSubmit = (data: ISyncFormData) => {+ updateMutation.mutate({ ...data });+ };++ const onDelete = () => {+ deleteMutation.mutate({ id: props.sync.id });+ };++ return (+ <IntegrationAttributeSyncCard+ {...props}+ onSubmit={onSubmit}+ onDelete={onDelete}+ isSubmitting={updateMutation.isPending}+ />+ );+};++export default EditIntegrationAttributeSyncCard;diff --git a/packages/features/ee/integration-attribute-sync/components/FieldMappingBuilder.tsx b/packages/features/ee/integration-attribute-sync/components/FieldMappingBuilder.tsxnew file mode 100644index 00000000000..22e8a2db272--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/components/FieldMappingBuilder.tsx@@ -0,0 +1,196 @@+import { useLocale } from "@calcom/lib/hooks/useLocale";+import { Button } from "@calcom/ui/components/button";+import { Input, Select, Switch } from "@calcom/ui/components/form";+import { Icon } from "@calcom/ui/components/icon";++import { getDefaultFieldMapping } from "../lib/fieldMappingHelpers";+import type {+ IFieldMappingFormState,+ IFieldMappingWithOptionalId,+} from "../repositories/IIntegrationAttributeSyncRepository";++type AttributeOptions = {+ label: string;+ value: string;+}[];++interface FieldMappingBuilderProps {+ value: IFieldMappingFormState;+ onChange: (value: IFieldMappingFormState) => void;+ attributeOptions: AttributeOptions;+ isLoadingAttributes?: boolean;+}++interface MappingRowProps {+ mapping: IFieldMappingWithOptionalId;+ onChange: (mapping: IFieldMappingWithOptionalId) => void;+ onRemove: () => void;+ attributeOptions: AttributeOptions;+ isLoading?: boolean;+ error?: string;+}++const MappingRow = ({ mapping, onChange, onRemove, attributeOptions, isLoading, error }: MappingRowProps) => {+ const { t } = useLocale();++ const selectedAttribute = attributeOptions.find((opt) => opt.value === mapping.attributeId);++ const handleFieldNameChange = (e: React.ChangeEvent<HTMLInputElement>) => {+ onChange({+ ...mapping,+ integrationFieldName: e.target.value,+ });+ };++ const handleAttributeChange = (selected: { value: string; label: string } | null) => {+ if (!selected) return;+ onChange({+ ...mapping,+ attributeId: selected.value,+ });+ };++ const handleEnabledChange = (checked: boolean) => {+ onChange({+ ...mapping,+ enabled: checked,+ });+ };++ return (+ <div>+ <div+ className={`bg-default border-subtle flex flex-wrap items-center gap-3 rounded-lg border p-3 ${error ? "border-red-500" : ""}`}>+ <div className="flex-1" style={{ minWidth: "200px" }}>+ <Input+ type="text"+ value={mapping.integrationFieldName}+ onChange={handleFieldNameChange}+ disabled={isLoading}+ placeholder={t("attribute_sync_field_placeholder")}+ className="h-7 text-sm"+ />+ </div>++ <Icon name="arrow-right" className="text-subtle h-4 w-4" />++ <div className="flex-1" style={{ minWidth: "200px" }}>+ <Select+ size="sm"+ placeholder={t("attribute_sync_select_attribute")}+ options={attributeOptions}+ value={selectedAttribute}+ onChange={handleAttributeChange}+ isLoading={isLoading}+ isDisabled={isLoading}+ className="w-full"+ />+ </div>++ <Switch checked={mapping.enabled} onCheckedChange={handleEnabledChange} disabled={isLoading} />++ <Button+ color="minimal"+ size="sm"+ StartIcon="trash-2"+ onClick={onRemove}+ disabled={isLoading}+ className="text-subtle hover:text-default"+ aria-label={t("remove")}+ />+ </div>+ {error && <p className="mt-1 text-xs text-red-600">{error}</p>}+ </div>+ );+};++export const FieldMappingBuilder = ({+ value,+ onChange,+ attributeOptions,+ isLoadingAttributes,+}: FieldMappingBuilderProps) => {+ const { t } = useLocale();++ // Find indices of rows with duplicate attribute mappings+ const duplicateIndices = new Set<number>();+ const seenAttributes = new Map<string, number>(); // attributeId -> first index+ value.mappings.forEach((mapping, index) => {+ if (mapping.attributeId) {+ const firstIndex = seenAttributes.get(mapping.attributeId);+ if (firstIndex !== undefined) {+ // Mark both the first occurrence and current as duplicates+ duplicateIndices.add(firstIndex);+ duplicateIndices.add(index);+ } else {+ seenAttributes.set(mapping.attributeId, index);+ }+ }+ });++ const handleAddMapping = () => {+ onChange({+ ...value,+ mappings: [...value.mappings, getDefaultFieldMapping()],+ });+ };++ const handleMappingChange = (index: number, newMapping: IFieldMappingWithOptionalId) => {+ const newMappings = [...value.mappings];+ newMappings[index] = newMapping;+ onChange({+ ...value,+ mappings: newMappings,+ });+ };++ const handleRemoveMapping = (index: number) => {+ onChange({+ ...value,+ mappings: value.mappings.filter((_, i) => i !== index),+ });+ };++ return (+ <div className="bg-default border-subtle rounded-2xl border p-2">+ <div className="ml-2 flex items-center gap-0.5">+ <div className="border-subtle rounded-lg border p-1">+ <Icon name="link" className="text-subtle h-4 w-4" />+ </div>+ <span className="text-emphasis ml-2 text-sm font-medium">{t("attribute_sync_field_mappings")}</span>+ </div>++ <div className="bg-muted mt-2 space-y-2 rounded-xl p-2">+ {value.mappings.length === 0 ? (+ <div className="text-subtle py-6 text-center text-sm">{t("attribute_sync_no_mappings")}</div>+ ) : (+ value.mappings.map((mapping, index) => (+ <MappingRow+ key={mapping.id || `new-${index}`}+ mapping={mapping}+ onChange={(newMapping) => handleMappingChange(index, newMapping)}+ onRemove={() => handleRemoveMapping(index)}+ attributeOptions={attributeOptions}+ isLoading={isLoadingAttributes}+ error={+ duplicateIndices.has(index)+ ? t("attribute_sync_duplicate_attribute_mapping")+ : undefined+ }+ />+ ))+ )}+ </div>++ <Button+ color="minimal"+ size="sm"+ StartIcon="plus"+ className="mt-2"+ onClick={handleAddMapping}+ disabled={isLoadingAttributes}>+ {t("attribute_sync_add_mapping")}+ </Button>+ </div>+ );+};diff --git a/packages/features/ee/integration-attribute-sync/components/IntegrationAttributeSyncCard.tsx b/packages/features/ee/integration-attribute-sync/components/IntegrationAttributeSyncCard.tsxnew file mode 100644index 00000000000..215e144ed80--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/components/IntegrationAttributeSyncCard.tsx@@ -0,0 +1,312 @@+import { useEffect, useState } from "react";+import { useForm, Controller } from "react-hook-form";++import { Dialog } from "@calcom/features/components/controlled-dialog";+import { useLocale } from "@calcom/lib/hooks/useLocale";+import type { Attribute } from "@calcom/app-store/routing-forms/types/types";+import { Button } from "@calcom/ui/components/button";+import { FormCard, FormCardBody } from "@calcom/ui/components/card";+import { ConfirmationDialogContent } from "@calcom/ui/components/dialog";+import { SelectField, Switch } from "@calcom/ui/components/form";+import { Icon } from "@calcom/ui/components/icon";++import {+ type IntegrationAttributeSync,+ type ISyncFormData,+ RuleOperatorEnum,+} from "../repositories/IIntegrationAttributeSyncRepository";+import { FieldMappingBuilder } from "./FieldMappingBuilder";+import { RuleBuilder } from "./RuleBuilder";++export interface IIntegrationAttributeSyncCardProps {+ sync?: IntegrationAttributeSync; // Optional for create mode+ credentialOptions: {+ value: string;+ label: string;+ }[];+ teamOptions: {+ value: string;+ label: string;+ }[];+ attributes: Attribute[];+ attributeOptions: {+ value: string;+ label: string;+ }[];+ organizationId: number;+ onSubmit: (data: ISyncFormData) => void;+ isSubmitting: boolean;+ onCancel?: () => void;+ onDelete?: () => void;+}++const IntegrationAttributeSyncCard = (+ props: IIntegrationAttributeSyncCardProps+) => {+ const {+ sync,+ credentialOptions,+ teamOptions,+ attributes,+ attributeOptions,+ organizationId,+ onSubmit,+ onCancel,+ onDelete,+ isSubmitting,+ } = props;++ const { t } = useLocale();+ const isCreateMode = !sync;+ const [showDeleteDialog, setShowDeleteDialog] = useState(false);++ // Initialize form with sync data or defaults+ const form = useForm<ISyncFormData>({+ defaultValues: sync+ ? {+ id: sync.id,+ name: sync.name,+ credentialId: sync.credentialId ?? undefined,+ enabled: sync.enabled,+ organizationId: sync.organizationId,+ ruleId: sync.attributeSyncRule?.id || "",+ rule: sync.attributeSyncRule?.rule || {+ operator: RuleOperatorEnum.AND,+ conditions: [],+ },+ syncFieldMappings: Array.isArray(sync.syncFieldMappings)+ ? sync.syncFieldMappings+ : [],+ }+ : {+ id: "",+ name: t("attribute_sync_new_integration_sync"),+ credentialId: undefined,+ enabled: true,+ organizationId,+ ruleId: "",+ rule: { operator: RuleOperatorEnum.AND, conditions: [] },+ syncFieldMappings: [],+ },+ });++ // Update form when sync prop changes (after refetch with new IDs)+ useEffect(() => {+ if (sync) {+ form.reset({+ id: sync.id,+ name: sync.name,+ credentialId: sync.credentialId ?? undefined,+ enabled: sync.enabled,+ organizationId: sync.organizationId,+ ruleId: sync.attributeSyncRule?.id || "",+ rule: sync.attributeSyncRule?.rule || {+ operator: RuleOperatorEnum.AND,+ conditions: [],+ },+ syncFieldMappings: Array.isArray(sync.syncFieldMappings)+ ? sync.syncFieldMappings+ : [],+ });+ }+ // Only need to run if the sync changes+ }, [sync?.id]);++ const onFormSubmit = (data: ISyncFormData) => {+ onSubmit(data);+ };++ const handleDelete = () => {+ if (!sync) return;+ setShowDeleteDialog(true);+ };++ const confirmDelete = () => {+ if (!sync || !onDelete) return;+ onDelete();+ setShowDeleteDialog(false);+ };++ const formName = form.watch("name");+ const isPending = isSubmitting;++ return (+ <>+ <form onSubmit={form.handleSubmit(onFormSubmit)}>+ <FormCard+ label={formName}+ leftIcon="link"+ collapsible={true}+ isLabelEditable={true}+ onLabelChange={(label) => {+ form.setValue("name", label, { shouldDirty: true });+ }}+ customActions={+ <Controller+ name="enabled"+ control={form.control}+ render={({ field }) => (+ <Switch+ checked={field.value}+ onCheckedChange={field.onChange}+ onClick={(e) => e.stopPropagation()}+ />+ )}+ />+ }+ deleteField={+ !isCreateMode && onDelete+ ? {+ check: () => true,+ fn: handleDelete,+ }+ : undefined+ }+ >+ <FormCardBody>+ <div className="space-y-4">+ <div className="bg-default border-subtle rounded-2xl border p-2">+ <div className="ml-2 flex items-center gap-0.5">+ <div className="border-subtle rounded-lg border p-1">+ <Icon name="key" className="text-subtle h-4 w-4" />+ </div>+ <span className="text-emphasis ml-2 text-sm font-medium">+ {t("attribute_sync_credential")}+ </span>+ </div>+ <div className="mt-2">+ <Controller+ name="credentialId"+ control={form.control}+ rules={{+ required: t("attribute_sync_credential_required"),+ validate: (value) => {+ if (!value || value <= 0) {+ return t("attribute_sync_credential_validation");+ }+ return true;+ },+ }}+ render={({ field, fieldState }) => (+ <>+ <SelectField+ placeholder={t("attribute_sync_select_credential")}+ options={credentialOptions}+ value={+ credentialOptions.find(+ (opt) => Number(opt.value) === field.value+ ) || null+ }+ onChange={(option) =>+ field.onChange(Number(option?.value))+ }+ />+ {fieldState.error && (+ <p className="mt-1 text-xs text-red-600">+ {fieldState.error.message}+ </p>+ )}+ </>+ )}+ />+ <p className="text-subtle mt-1 text-xs">+ {t("attribute_sync_credential_description")}+ </p>+ </div>+ </div>++ <div>+ <label className="text-emphasis mb-2 block text-sm font-medium">+ {t("attribute_sync_user_filter_rules")}+ </label>+ <Controller+ name="rule"+ control={form.control}+ render={({ field }) => (+ <RuleBuilder+ value={field.value}+ onChange={field.onChange}+ teamOptions={teamOptions}+ attributes={attributes ?? []}+ />+ )}+ />+ <p className="text-subtle mt-1 text-xs">+ {t("attribute_sync_user_filter_rules_description")}+ </p>+ </div>++ <div>+ <label className="text-emphasis mb-2 block text-sm font-medium">+ {t("attribute_sync_field_mappings")}+ </label>+ <Controller+ name="syncFieldMappings"+ control={form.control}+ rules={{+ validate: (mappings) => {+ const seenAttributes = new Set<string>();+ for (const mapping of mappings || []) {+ if (+ mapping.attributeId &&+ seenAttributes.has(mapping.attributeId)+ ) {+ return t(+ "attribute_sync_duplicate_attribute_mapping"+ );+ }+ if (mapping.attributeId)+ seenAttributes.add(mapping.attributeId);+ }+ return true;+ },+ }}+ render={({ field }) => (+ <FieldMappingBuilder+ value={{ mappings: field.value || [] }}+ onChange={(fieldMappings) =>+ field.onChange(fieldMappings.mappings)+ }+ attributeOptions={attributeOptions}+ />+ )}+ />+ <p className="text-subtle mt-1 text-xs">+ {t("attribute_sync_field_mappings_description")}+ </p>+ </div>++ <div className="border-subtle flex justify-end gap-2 border-t pt-4">+ {isCreateMode && onCancel && (+ <Button type="button" color="secondary" onClick={onCancel}>+ {t("cancel")}+ </Button>+ )}+ <Button+ type="submit"+ loading={isPending}+ disabled={!form.formState.isDirty}+ >+ {isCreateMode ? t("create") : t("save")}+ </Button>+ </div>+ </div>+ </FormCardBody>+ </FormCard>+ </form>++ <Dialog open={showDeleteDialog} onOpenChange={setShowDeleteDialog}>+ <ConfirmationDialogContent+ variety="danger"+ title={t("attribute_sync_delete_title")}+ confirmBtnText={t("delete")}+ onConfirm={confirmDelete}+ >+ {t("attribute_sync_delete_confirmation")}+ </ConfirmationDialogContent>+ </Dialog>+ </>+ );+};++export default IntegrationAttributeSyncCard;diff --git a/packages/features/ee/integration-attribute-sync/components/NewIntegrationAttributeSyncCard.tsx b/packages/features/ee/integration-attribute-sync/components/NewIntegrationAttributeSyncCard.tsxnew file mode 100644index 00000000000..e2c4e0c516c--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/components/NewIntegrationAttributeSyncCard.tsx@@ -0,0 +1,47 @@+import { useLocale } from "@calcom/lib/hooks/useLocale";+import { trpc } from "@calcom/trpc/react";+import { showToast } from "@calcom/ui/components/toast";++import type { ISyncFormData } from "../repositories/IIntegrationAttributeSyncRepository";+import IntegrationAttributeSyncCard from "./IntegrationAttributeSyncCard";+import type { IIntegrationAttributeSyncCardProps } from "./IntegrationAttributeSyncCard";++type INewIntegrationAttributeSyncCardProps = Pick<+ IIntegrationAttributeSyncCardProps,+ "credentialOptions" | "teamOptions" | "attributes" | "organizationId" | "onCancel" | "attributeOptions"+>;++const NewIntegrationAttributeSyncCard = (props: INewIntegrationAttributeSyncCardProps) => {+ const { t } = useLocale();+ const utils = trpc.useUtils();+ const createMutation = trpc.viewer.attributeSync.createAttributeSync.useMutation({+ onSuccess: () => {+ utils.viewer.attributeSync.getAllAttributeSyncs.invalidate();+ showToast(t("attribute_sync_created_successfully"), "success");+ props.onCancel?.();+ },+ onError: (error) => {+ showToast(error.message, "error");+ },+ });++ const onSubmit = (data: ISyncFormData) => {+ if (!data.credentialId) {+ showToast(t("attribute_sync_credential_required"), "error");+ return;+ }++ createMutation.mutate({+ name: data.name,+ credentialId: data.credentialId,+ rule: data.rule,+ syncFieldMappings: data.syncFieldMappings,+ enabled: data.enabled,+ });+ };+ return (+ <IntegrationAttributeSyncCard {...props} onSubmit={onSubmit} isSubmitting={createMutation.isPending} />+ );+};++export default NewIntegrationAttributeSyncCard;diff --git a/packages/features/ee/integration-attribute-sync/components/RuleBuilder.tsx b/packages/features/ee/integration-attribute-sync/components/RuleBuilder.tsxnew file mode 100644index 00000000000..9aec9ac07c2--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/components/RuleBuilder.tsx@@ -0,0 +1,495 @@+import type { MultiValue, SingleValue } from "react-select";++import { useLocale } from "@calcom/lib/hooks/useLocale";+import type { Attribute } from "@calcom/app-store/routing-forms/types/types";+import { Button } from "@calcom/ui/components/button";+import { Input, Select } from "@calcom/ui/components/form";+import { Icon } from "@calcom/ui/components/icon";++import {+ formatConditionValue,+ generateConditionId,+ getConditionTypeOptions,+ getDefaultAttributeCondition,+ getDefaultTeamCondition,+ getOperatorOptionsForAttributeType,+ getParentOperatorOptions,+ getTeamOperatorOptions,+ isArrayOperator,+ isTeamCondition,+ type TAttributeSyncRuleConditionWithId,+} from "../lib/ruleHelpers";+import {+ ConditionIdentifierEnum,+ type ConditionOperatorEnum,+ type IAttributeCondition,+ type IAttributeSyncRule,+ type ITeamCondition,+ type RuleOperatorEnum,+ type TAttributeSyncRuleCondition,+} from "../repositories/IIntegrationAttributeSyncRepository";++const ensureConditionHasId = (condition: TAttributeSyncRuleCondition): TAttributeSyncRuleConditionWithId => {+ if ("_id" in condition && condition._id) {+ return condition as TAttributeSyncRuleConditionWithId;+ }+ return { ...condition, _id: generateConditionId() } as TAttributeSyncRuleConditionWithId;+};++interface RuleBuilderProps {+ value: IAttributeSyncRule;+ onChange: (value: IAttributeSyncRule) => void;+ teamOptions: { value: string; label: string }[];+ attributes: Attribute[];+ isLoadingTeams?: boolean;+ isLoadingAttributes?: boolean;+}++interface ConditionComponentProps {+ condition: TAttributeSyncRuleCondition;+ onChange: (condition: TAttributeSyncRuleCondition) => void;+ onRemove: () => void;+ teamOptions: { value: string; label: string }[];+ attributes: Attribute[];+ isLoading?: boolean;+}++const ConditionComponent = ({+ condition,+ onChange,+ onRemove,+ teamOptions,+ attributes,+ isLoading,+}: ConditionComponentProps) => {+ const { t } = useLocale();+ const conditionTypeOptions = getConditionTypeOptions(t);+ const conditionTypeOption = conditionTypeOptions.find((opt) => opt.value === condition.identifier);++ const handleTypeChange = (newType: { value: ConditionIdentifierEnum; label: string } | null) => {+ if (!newType) return;++ if (newType.value === ConditionIdentifierEnum.TEAM_ID) {+ onChange(getDefaultTeamCondition());+ } else {+ onChange(getDefaultAttributeCondition());+ }+ };++ return (+ <div className="bg-default border-subtle flex flex-wrap items-center gap-2 rounded-lg border p-3">+ {/* Condition type selector */}+ <Select+ size="sm"+ className="w-32"+ value={conditionTypeOption}+ onChange={handleTypeChange}+ options={conditionTypeOptions}+ isDisabled={isLoading}+ />++ {/* Render team or attribute specific fields */}+ {isTeamCondition(condition) ? (+ <TeamConditionFields+ condition={condition}+ onChange={onChange}+ teamOptions={teamOptions}+ isLoading={isLoading}+ />+ ) : (+ <AttributeConditionFields+ condition={condition}+ onChange={onChange}+ attributes={attributes}+ isLoading={isLoading}+ />+ )}++ <Button+ color="minimal"+ size="sm"+ StartIcon="trash-2"+ onClick={onRemove}+ disabled={isLoading}+ className="text-subtle hover:text-default"+ />+ </div>+ );+};++interface TeamConditionFieldsProps {+ condition: ITeamCondition;+ onChange: (condition: TAttributeSyncRuleCondition) => void;+ teamOptions: { value: string; label: string }[];+ isLoading?: boolean;+}++const TeamConditionFields = ({ condition, onChange, teamOptions, isLoading }: TeamConditionFieldsProps) => {+ const { t } = useLocale();+ const teamOperatorOptions = getTeamOperatorOptions(t);+ const operatorOption = teamOperatorOptions.find((opt) => opt.value === condition.operator);+ const isMulti = isArrayOperator(condition.operator);++ const selectedTeams = isMulti+ ? teamOptions.filter((opt) => condition.value.includes(Number(opt.value)))+ : teamOptions.find((opt) => Number(opt.value) === condition.value[0]);++ const handleOperatorChange = (newOperator: { value: ConditionOperatorEnum; label: string } | null) => {+ if (!newOperator) return;++ const formattedValue = formatConditionValue(newOperator.value, condition.value) as number[];+ onChange({+ ...condition,+ operator: newOperator.value,+ value: formattedValue,+ });+ };++ const handleTeamsChange = (+ selected: MultiValue<{ value: string; label: string }> | SingleValue<{ value: string; label: string }>+ ) => {+ if (!selected) {+ onChange({ ...condition, value: [] });+ return;+ }++ if (Array.isArray(selected)) {+ onChange({+ ...condition,+ value: selected.map((s) => Number(s.value)),+ });+ } else {+ const singleValue = selected as { value: string; label: string };+ onChange({+ ...condition,+ value: [Number(singleValue.value)],+ });+ }+ };++ return (+ <>+ <span className="text-default text-sm">{t("team").toLowerCase()}</span>++ <Select+ size="sm"+ className="w-40"+ value={operatorOption}+ onChange={handleOperatorChange}+ options={teamOperatorOptions}+ isDisabled={isLoading}+ />++ <div className="flex-1" style={{ minWidth: "200px" }}>+ <Select+ size="sm"+ isMulti={isMulti}+ value={selectedTeams}+ onChange={handleTeamsChange}+ options={teamOptions}+ isLoading={isLoading}+ isDisabled={isLoading}+ placeholder={t("attribute_sync_select_teams")}+ className="w-full"+ />+ </div>+ </>+ );+};++interface AttributeConditionFieldsProps {+ condition: IAttributeCondition;+ onChange: (condition: TAttributeSyncRuleCondition) => void;+ attributes: Attribute[];+ isLoading?: boolean;+}++const AttributeConditionFields = ({+ condition,+ onChange,+ attributes,+ isLoading,+}: AttributeConditionFieldsProps) => {+ const { t } = useLocale();+ const selectedAttribute = attributes.find((attr) => attr.id === condition.attributeId);++ const attributeOptions = attributes.map((attr) => ({+ value: attr.id,+ label: attr.name,+ }));++ const operatorOptions = selectedAttribute+ ? getOperatorOptionsForAttributeType(selectedAttribute.type, t)+ : [];++ const operatorOption = operatorOptions.find((opt) => opt.value === condition.operator);++ const handleAttributeChange = (selected: { value: string; label: string } | null) => {+ if (!selected) return;++ const newAttribute = attributes.find((attr) => attr.id === selected.value);+ if (!newAttribute) return;++ // Reset operator and value when attribute changes+ const defaultOperator = getOperatorOptionsForAttributeType(newAttribute.type, t)[0];++ onChange({+ ...condition,+ attributeId: selected.value,+ operator: defaultOperator.value,+ value: [],+ });+ };++ const handleOperatorChange = (newOperator: { value: ConditionOperatorEnum; label: string } | null) => {+ if (!newOperator) return;++ const formattedValue = formatConditionValue(newOperator.value, condition.value) as string[];+ onChange({+ ...condition,+ operator: newOperator.value,+ value: formattedValue,+ });+ };++ const handleValueChange = (+ selected: MultiValue<{ value: string; label: string }> | SingleValue<{ value: string; label: string }>+ ) => {+ if (!selected) {+ onChange({ ...condition, value: [] });+ return;+ }++ if (Array.isArray(selected)) {+ onChange({+ ...condition,+ value: selected.map((s) => s.value),+ });+ } else {+ const singleValue = selected as { value: string; label: string };+ onChange({+ ...condition,+ value: [singleValue.value],+ });+ }+ };++ const handleTextValueChange = (e: React.ChangeEvent<HTMLInputElement>) => {+ onChange({+ ...condition,+ value: [e.target.value],+ });+ };++ const handleNumberValueChange = (e: React.ChangeEvent<HTMLInputElement>) => {+ onChange({+ ...condition,+ value: [e.target.value],+ });+ };++ // Render value input based on attribute type+ const renderValueInput = () => {+ if (!selectedAttribute) {+ return (+ <div className="text-subtle flex-1 text-sm" style={{ minWidth: "200px" }}>+ {t("attribute_sync_select_attribute_first")}+ </div>+ );+ }++ const isMulti = isArrayOperator(condition.operator);++ switch (selectedAttribute.type) {+ case "SINGLE_SELECT":+ case "MULTI_SELECT": {+ const valueOptions = selectedAttribute.options.map((opt: { id: string; value: string }) => ({+ value: opt.id,+ label: opt.value,+ }));++ const selectedValues = isMulti+ ? valueOptions.filter((opt: { value: string; label: string }) => condition.value.includes(opt.value))+ : valueOptions.find((opt: { value: string; label: string }) => condition.value[0] === opt.value);++ return (+ <div className="flex-1" style={{ minWidth: "200px" }}>+ <Select+ size="sm"+ isMulti={isMulti}+ value={selectedValues}+ onChange={handleValueChange}+ options={valueOptions}+ isLoading={isLoading}+ isDisabled={isLoading}+ placeholder={t("attribute_sync_select_values")}+ className="w-full"+ />+ </div>+ );+ }++ case "TEXT":+ return (+ <div className="flex-1" style={{ minWidth: "200px" }}>+ <Input+ type="text"+ value={condition.value[0] || ""}+ onChange={handleTextValueChange}+ disabled={isLoading}+ placeholder={t("attribute_sync_enter_text_value")}+ className="h-7 text-sm"+ />+ </div>+ );++ case "NUMBER":+ return (+ <div className="flex-1" style={{ minWidth: "200px" }}>+ <Input+ type="number"+ value={condition.value[0] || ""}+ onChange={handleNumberValueChange}+ disabled={isLoading}+ placeholder={t("attribute_sync_enter_number_value")}+ className="h-7 text-sm"+ />+ </div>+ );+ }+ };++ return (+ <>+ <span className="text-default text-sm">{t("attribute").toLowerCase()}</span>++ <Select+ size="sm"+ className="w-48"+ value={attributeOptions.find((opt) => opt.value === condition.attributeId)}+ onChange={handleAttributeChange}+ options={attributeOptions}+ isLoading={isLoading}+ isDisabled={isLoading}+ placeholder={t("attribute_sync_select_attribute")}+ />++ {selectedAttribute && (+ <>+ <Select+ size="sm"+ className="w-40"+ value={operatorOption}+ onChange={handleOperatorChange}+ options={operatorOptions}+ isDisabled={isLoading}+ />++ {renderValueInput()}+ </>+ )}+ </>+ );+};++export const RuleBuilder = ({+ value,+ onChange,+ teamOptions,+ attributes,+ isLoadingTeams,+ isLoadingAttributes,+}: RuleBuilderProps) => {+ const { t } = useLocale();+ const parentOperatorOptions = getParentOperatorOptions(t);+ const parentOperatorOption = parentOperatorOptions.find((opt) => opt.value === value.operator);+ const isLoading = isLoadingTeams || isLoadingAttributes;++ const handleOperatorChange = (newOperator: { value: RuleOperatorEnum; label: string } | null) => {+ if (!newOperator) return;+ onChange({+ ...value,+ operator: newOperator.value,+ });+ };++ const handleAddCondition = () => {+ onChange({+ ...value,+ conditions: [...value.conditions, getDefaultTeamCondition()],+ });+ };++ const handleConditionChange = (index: number, newCondition: TAttributeSyncRuleCondition) => {+ const newConditions = [...value.conditions];+ newConditions[index] = newCondition;+ onChange({+ ...value,+ conditions: newConditions,+ });+ };++ const handleRemoveCondition = (index: number) => {+ onChange({+ ...value,+ conditions: value.conditions.filter((_, i) => i !== index),+ });+ };++ return (+ <div className="bg-default border-subtle rounded-2xl border p-2">+ <div className="ml-2 flex items-center gap-0.5">+ <div className="border-subtle rounded-lg border p-1">+ <Icon name="filter" className="text-subtle h-4 w-4" />+ </div>+ <span className="text-emphasis ml-2 text-sm font-medium">{t("attribute_sync_user_filter_rules")}</span>+ </div>++ <div className="mt-2 flex flex-wrap items-center gap-2 px-2">+ <span className="text-default text-sm">{t("attribute_sync_sync_users_where")}</span>+ <Select+ size="sm"+ className="w-28"+ value={parentOperatorOption}+ onChange={handleOperatorChange}+ options={parentOperatorOptions}+ isDisabled={isLoading}+ />+ <span className="text-default text-sm">{t("attribute_sync_conditions_match")}</span>+ </div>++ <div className="bg-muted mt-2 space-y-2 rounded-xl p-2">+ {value.conditions.length === 0 ? (+ <div className="text-subtle py-6 text-center text-sm">+ {t("attribute_sync_no_conditions")}+ </div>+ ) : (+ value.conditions.map((condition, index) => {+ const conditionWithId = ensureConditionHasId(condition);+ return (+ <ConditionComponent+ key={conditionWithId._id}+ condition={conditionWithId}+ onChange={(newCondition) => handleConditionChange(index, newCondition)}+ onRemove={() => handleRemoveCondition(index)}+ teamOptions={teamOptions}+ attributes={attributes}+ isLoading={isLoading}+ />+ );+ })+ )}+ </div>++ <Button+ color="minimal"+ size="sm"+ StartIcon="plus"+ className="mt-2"+ onClick={handleAddCondition}+ disabled={isLoading}>+ {t("attribute_sync_add_condition")}+ </Button>+ </div>+ );+};diff --git a/packages/features/ee/integration-attribute-sync/constants.ts b/packages/features/ee/integration-attribute-sync/constants.tsnew file mode 100644index 00000000000..a3208a7d7d5--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/constants.ts@@ -0,0 +1,2 @@+/* Slugs of apps that support attribute syncing */+export const enabledAppSlugs = ["salesforce"];diff --git a/packages/features/ee/integration-attribute-sync/di/IntegrationAttributeSyncRepository.module.ts b/packages/features/ee/integration-attribute-sync/di/IntegrationAttributeSyncRepository.module.tsnew file mode 100644index 00000000000..870e09ed36f--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/di/IntegrationAttributeSyncRepository.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 { PrismaIntegrationAttributeSyncRepository } from "../repositories/PrismaIntegrationAttributeSyncRepository";+import { INTEGRATION_ATTRIBUTE_SYNC_DI_TOKENS } from "./tokens";++export const integrationAttributeSyncRepositoryModule = createModule();+const token = INTEGRATION_ATTRIBUTE_SYNC_DI_TOKENS.INTEGRATION_ATTRIBUTE_SYNC_REPOSITORY;+const moduleToken = INTEGRATION_ATTRIBUTE_SYNC_DI_TOKENS.INTEGRATION_ATTRIBUTE_SYNC_REPOSITORY_MODULE;+const loadModule = bindModuleToClassOnToken({+ module: integrationAttributeSyncRepositoryModule,+ moduleToken,+ token,+ classs: PrismaIntegrationAttributeSyncRepository,+ dep: prismaModuleLoader,+});++export const moduleLoader: ModuleLoader = {+ token,+ loadModule,+};++export type { IIntegrationAttributeSyncRepository } from "../repositories/IIntegrationAttributeSyncRepository";diff --git a/packages/features/ee/integration-attribute-sync/di/IntegrationAttributeSyncService.container.ts b/packages/features/ee/integration-attribute-sync/di/IntegrationAttributeSyncService.container.tsnew file mode 100644index 00000000000..30a5e8b0b79--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/di/IntegrationAttributeSyncService.container.ts@@ -0,0 +1,16 @@+import { createContainer } from "@calcom/features/di/di";++import {+ type IntegrationAttributeSyncService,+ moduleLoader as integrationAttributeSyncServiceModule,+} from "./IntegrationAttributeSyncService.module";++const integrationAttributeSyncServiceContainer = createContainer();++export function getIntegrationAttributeSyncService(): IntegrationAttributeSyncService {+ integrationAttributeSyncServiceModule.loadModule(integrationAttributeSyncServiceContainer);++ return integrationAttributeSyncServiceContainer.get<IntegrationAttributeSyncService>(+ integrationAttributeSyncServiceModule.token+ );+}diff --git a/packages/features/ee/integration-attribute-sync/di/IntegrationAttributeSyncService.module.ts b/packages/features/ee/integration-attribute-sync/di/IntegrationAttributeSyncService.module.tsnew file mode 100644index 00000000000..3c1fdd0ade0--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/di/IntegrationAttributeSyncService.module.ts@@ -0,0 +1,27 @@+import { bindModuleToClassOnToken, createModule, type ModuleLoader } from "@calcom/features/di/di";+import { moduleLoader as credentialRepositoryModuleLoader } from "@calcom/features/di/modules/Credential";+import { IntegrationAttributeSyncService } from "@calcom/features/ee/integration-attribute-sync/services/IntegrationAttributeSyncService";++import { INTEGRATION_ATTRIBUTE_SYNC_DI_TOKENS } from "./tokens";+import { moduleLoader as integrationAttributeSyncRepositoryModuleLoader } from "./IntegrationAttributeSyncRepository.module";++export const integrationAttributeSyncServiceModule = createModule();+const token = INTEGRATION_ATTRIBUTE_SYNC_DI_TOKENS.INTEGRATION_ATTRIBUTE_SYNC_SERVICE;+const moduleToken = INTEGRATION_ATTRIBUTE_SYNC_DI_TOKENS.INTEGRATION_ATTRIBUTE_SYNC_SERVICE_MODULE;+const loadModule = bindModuleToClassOnToken({+ module: integrationAttributeSyncServiceModule,+ moduleToken,+ token,+ classs: IntegrationAttributeSyncService,+ depsMap: {+ credentialRepository: credentialRepositoryModuleLoader,+ integrationAttributeSyncRepository: integrationAttributeSyncRepositoryModuleLoader,+ },+});++export const moduleLoader: ModuleLoader = {+ token,+ loadModule,+};++export type { IntegrationAttributeSyncService };diff --git a/packages/features/ee/integration-attribute-sync/di/tokens.ts b/packages/features/ee/integration-attribute-sync/di/tokens.tsnew file mode 100644index 00000000000..aa1378c8267--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/di/tokens.ts@@ -0,0 +1,6 @@+export const INTEGRATION_ATTRIBUTE_SYNC_DI_TOKENS = {+ INTEGRATION_ATTRIBUTE_SYNC_SERVICE: Symbol("IntegrationAttributeSyncService"),+ INTEGRATION_ATTRIBUTE_SYNC_SERVICE_MODULE: Symbol("IntegrationAttributeSyncServiceModule"),+ INTEGRATION_ATTRIBUTE_SYNC_REPOSITORY: Symbol("IntegrationAttributeSyncRepository"),+ INTEGRATION_ATTRIBUTE_SYNC_REPOSITORY_MODULE: Symbol("IntegrationAttributeSyncRepositoryModule"),+};diff --git a/packages/features/ee/integration-attribute-sync/lib/fieldMappingHelpers.ts b/packages/features/ee/integration-attribute-sync/lib/fieldMappingHelpers.tsnew file mode 100644index 00000000000..99d07d347fb--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/lib/fieldMappingHelpers.ts@@ -0,0 +1,7 @@+import type { IFieldMappingWithOptionalId } from "../repositories/IIntegrationAttributeSyncRepository";++export const getDefaultFieldMapping = (): IFieldMappingWithOptionalId => ({+ integrationFieldName: "",+ attributeId: "",+ enabled: true,+});diff --git a/packages/features/ee/integration-attribute-sync/lib/ruleHelpers.ts b/packages/features/ee/integration-attribute-sync/lib/ruleHelpers.tsnew file mode 100644index 00000000000..1d82a23b119--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/lib/ruleHelpers.ts@@ -0,0 +1,108 @@+import type { AttributeType } from "@calcom/prisma/enums";++import {+ ConditionIdentifierEnum,+ ConditionOperatorEnum,+ type IAttributeCondition,+ type ITeamCondition,+ RuleOperatorEnum,+ type TAttributeSyncRuleCondition,+} from "../repositories/IIntegrationAttributeSyncRepository";++type TFunction = (key: string) => string;++// Unique ID generator for React keys+export const generateConditionId = (): string => {+ return crypto.randomUUID();+};++// Extended condition types with client-side ID for React keys+export interface ITeamConditionWithId extends ITeamCondition {+ _id: string;+}++export interface IAttributeConditionWithId extends IAttributeCondition {+ _id: string;+}++export type TAttributeSyncRuleConditionWithId = ITeamConditionWithId | IAttributeConditionWithId;++// Factory functions+export const getDefaultTeamCondition = (): ITeamConditionWithId => ({+ _id: generateConditionId(),+ identifier: ConditionIdentifierEnum.TEAM_ID,+ operator: ConditionOperatorEnum.IN,+ value: [],+});++export const getDefaultAttributeCondition = (): IAttributeConditionWithId => ({+ _id: generateConditionId(),+ identifier: ConditionIdentifierEnum.ATTRIBUTE_ID,+ attributeId: "",+ operator: ConditionOperatorEnum.EQUALS,+ value: [],+});++// Type guards+export const isTeamCondition = (condition: TAttributeSyncRuleCondition): condition is ITeamCondition => {+ return condition.identifier === ConditionIdentifierEnum.TEAM_ID;+};++export const isAttributeCondition = (+ condition: TAttributeSyncRuleCondition+): condition is IAttributeCondition => {+ return condition.identifier === ConditionIdentifierEnum.ATTRIBUTE_ID;+};++export const isArrayOperator = (operator: ConditionOperatorEnum): boolean => {+ return operator === ConditionOperatorEnum.IN || operator === ConditionOperatorEnum.NOT_IN;+};++export const formatConditionValue = (+ operator: ConditionOperatorEnum,+ value: number[] | string[]+): number[] | string[] => {+ if (isArrayOperator(operator)) {+ return Array.isArray(value) ? value : value ? [value] : [];+ } else {+ return Array.isArray(value) ? value.slice(0, 1) : value ? [value] : [];+ }+};++// Operator options for teams+export const getTeamOperatorOptions = (t: TFunction) => [+ { value: ConditionOperatorEnum.IN, label: t("attribute_sync_operator_is_any_of") },+ { value: ConditionOperatorEnum.NOT_IN, label: t("attribute_sync_operator_is_not_any_of") },+];++// Operator options based on attribute type+export const getOperatorOptionsForAttributeType = (type: AttributeType, t: TFunction) => {+ switch (type) {+ case "SINGLE_SELECT":+ return [+ { value: ConditionOperatorEnum.EQUALS, label: t("attribute_sync_operator_is") },+ { value: ConditionOperatorEnum.NOT_EQUALS, label: t("attribute_sync_operator_is_not") },+ ];+ case "MULTI_SELECT":+ return [+ { value: ConditionOperatorEnum.IN, label: t("attribute_sync_operator_includes_any_of") },+ { value: ConditionOperatorEnum.NOT_IN, label: t("attribute_sync_operator_does_not_include") },+ ];+ case "TEXT":+ case "NUMBER":+ return [+ { value: ConditionOperatorEnum.EQUALS, label: t("attribute_sync_operator_equals") },+ { value: ConditionOperatorEnum.NOT_EQUALS, label: t("attribute_sync_operator_not_equals") },+ ];+ }+};++export const getParentOperatorOptions = (t: TFunction) => [+ { value: RuleOperatorEnum.AND, label: t("all") },+ { value: RuleOperatorEnum.OR, label: t("any") },+];++export const getConditionTypeOptions = (t: TFunction) => [+ { value: ConditionIdentifierEnum.TEAM_ID, label: t("team") },+ { value: ConditionIdentifierEnum.ATTRIBUTE_ID, label: t("attribute") },+];diff --git a/packages/features/ee/integration-attribute-sync/mappers/IntegrationAttributeSyncOutputMapper.ts b/packages/features/ee/integration-attribute-sync/mappers/IntegrationAttributeSyncOutputMapper.tsnew file mode 100644index 00000000000..e79ebcb2e55--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/mappers/IntegrationAttributeSyncOutputMapper.ts@@ -0,0 +1,53 @@+import type {+ AttributeSyncRule as PrismaAttributeSyncRule,+ IntegrationAttributeSync as PrismaIntegrationAttributeSync,+ AttributeSyncFieldMapping as PrismaAttributeSyncFieldMapping,+} from "@calcom/prisma/client";++import type {+ AttributeSyncRule,+ IntegrationAttributeSync,+} from "../repositories/IIntegrationAttributeSyncRepository";+import { AttributeSyncIntegrations } from "../repositories/IIntegrationAttributeSyncRepository";+import { attributeSyncRuleSchema } from "../schemas/zod";++type PrismaIntegrationAttributeSyncWithRelations = Pick<+ PrismaIntegrationAttributeSync,+ "id" | "name" | "organizationId" | "integration" | "credentialId" | "enabled"+> & {+ attributeSyncRule: PrismaAttributeSyncRule | null;+ syncFieldMappings: Pick<+ PrismaAttributeSyncFieldMapping,+ "id" | "integrationFieldName" | "attributeId" | "enabled"+ >[];+};++export class IntegrationAttributeSyncOutputMapper {+ static attributeSyncRuleToDomain(prisma: PrismaAttributeSyncRule): AttributeSyncRule {+ const parsedRules = attributeSyncRuleSchema.parse(prisma.rule);++ return {+ ...prisma,+ rule: parsedRules,+ };+ }++ static toDomain(prisma: PrismaIntegrationAttributeSyncWithRelations): IntegrationAttributeSync {+ return {+ id: prisma.id,+ name: prisma.name,+ organizationId: prisma.organizationId,+ integration: prisma.integration as AttributeSyncIntegrations,+ credentialId: prisma.credentialId ?? undefined,+ enabled: prisma.enabled,+ attributeSyncRule: prisma.attributeSyncRule+ ? IntegrationAttributeSyncOutputMapper.attributeSyncRuleToDomain(prisma.attributeSyncRule)+ : null,+ syncFieldMappings: prisma.syncFieldMappings,+ };+ }++ static toDomainList(prismaList: PrismaIntegrationAttributeSyncWithRelations[]): IntegrationAttributeSync[] {+ return prismaList.map(IntegrationAttributeSyncOutputMapper.toDomain);+ }+}diff --git a/packages/features/ee/integration-attribute-sync/repositories/IIntegrationAttributeSyncRepository.ts b/packages/features/ee/integration-attribute-sync/repositories/IIntegrationAttributeSyncRepository.tsnew file mode 100644index 00000000000..df6c90fcd76--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/repositories/IIntegrationAttributeSyncRepository.ts@@ -0,0 +1,145 @@+export enum AttributeSyncIntegrations {+ SALESFORCE = "salesforce",+}++export enum RuleOperatorEnum {+ AND = "AND",+ OR = "OR",+}++export enum ConditionIdentifierEnum {+ TEAM_ID = "teamId",+ ATTRIBUTE_ID = "attributeId",+}++export enum ConditionOperatorEnum {+ EQUALS = "equals",+ NOT_EQUALS = "notEquals",+ IN = "in",+ NOT_IN = "notIn",+}++// Condition types+export interface ITeamCondition {+ identifier: ConditionIdentifierEnum.TEAM_ID;+ operator: ConditionOperatorEnum;+ value: number[];+}++export interface IAttributeCondition {+ identifier: ConditionIdentifierEnum.ATTRIBUTE_ID;+ operator: ConditionOperatorEnum;+ attributeId: string;+ value: string[];+}++export type TAttributeSyncRuleCondition = ITeamCondition | IAttributeCondition;++export interface IAttributeSyncRule {+ operator: RuleOperatorEnum;+ conditions: TAttributeSyncRuleCondition[];+}++// Field mapping types+export interface INewFieldMapping {+ integrationFieldName: string;+ attributeId: string;+ enabled: boolean;+}++export interface IFieldMapping extends INewFieldMapping {+ id: string;+}++export interface IFieldMappingWithOptionalId extends INewFieldMapping {+ id?: string;+}++export interface IFieldMappingFormState {+ mappings: IFieldMappingWithOptionalId[];+}++export interface ISyncFormData {+ id: string;+ name: string;+ credentialId?: number;+ enabled: boolean;+ organizationId: number;+ ruleId: string;+ rule: IAttributeSyncRule;+ syncFieldMappings: (IFieldMapping | INewFieldMapping)[];+}+export interface IntegrationAttributeSync {+ id: string;+ organizationId: number;+ name: string;+ integration: AttributeSyncIntegrations;+ credentialId?: number;+ enabled: boolean;+ attributeSyncRule: AttributeSyncRule | null;+ syncFieldMappings: AttributeSyncFieldMapping[];+}++export interface AttributeSyncRule {+ id: string;+ rule: IAttributeSyncRule;+}++export interface AttributeSyncFieldMapping {+ id: string;+ integrationFieldName: string;+ attributeId: string;+ enabled: boolean;+}++export interface IIntegrationAttributeSyncCreateParams {+ name: string;+ organizationId: number;+ integration: AttributeSyncIntegrations;+ credentialId: number;+ enabled: boolean;+ rule: IAttributeSyncRule;+ syncFieldMappings: Omit<AttributeSyncFieldMapping, "id">[];+}++// TRPC schema types+export interface ICreateAttributeSyncInput {+ name: string;+ credentialId: number;+ rule: IAttributeSyncRule;+ syncFieldMappings: INewFieldMapping[];+ enabled: boolean;+}++export interface IUpdateAttributeSyncInput {+ id: string;+ name: string;+ credentialId?: number;+ enabled: boolean;+ organizationId: number;+ ruleId: string;+ rule: IAttributeSyncRule;+ syncFieldMappings: IFieldMappingWithOptionalId[];+}++export interface IIntegrationAttributeSyncRepository {+ getByOrganizationId(organizationId: number): Promise<IntegrationAttributeSync[]>;+ getById(id: string): Promise<IntegrationAttributeSync | null>;+ getSyncFieldMappings(integrationAttributeSyncId: string): Promise<AttributeSyncFieldMapping[]>;+ getMappedAttributeIdsByOrganization(organizationId: number, excludeSyncId?: string): Promise<string[]>;+ getAttributeIdsByOrganization(organizationId: number, attributeIds: string[]): Promise<string[]>;+ create(params: IIntegrationAttributeSyncCreateParams): Promise<IntegrationAttributeSync>;+ updateTransactionWithRuleAndMappings(params: IIntegrationAttributeSyncUpdateParams): Promise<void>;+ deleteById(id: string): Promise<void>;+}++export interface IIntegrationAttributeSyncUpdateParams {+ integrationAttributeSync: Omit<+ IntegrationAttributeSync,+ "attributeSyncRule" | "syncFieldMappings" | "integration"+ >;+ attributeSyncRule: AttributeSyncRule;+ fieldMappingsToCreate: Omit<AttributeSyncFieldMapping, "id">[];+ fieldMappingsToUpdate: AttributeSyncFieldMapping[];+ fieldMappingsToDelete: string[];+}diff --git a/packages/features/ee/integration-attribute-sync/repositories/PrismaIntegrationAttributeSyncRepository.ts b/packages/features/ee/integration-attribute-sync/repositories/PrismaIntegrationAttributeSyncRepository.tsnew file mode 100644index 00000000000..154fbd36a15--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/repositories/PrismaIntegrationAttributeSyncRepository.ts@@ -0,0 +1,210 @@+import type { Prisma } from "@calcom/prisma/client";+import type { PrismaClient } from "@calcom/prisma";++import { IntegrationAttributeSyncOutputMapper } from "../mappers/IntegrationAttributeSyncOutputMapper";+import type {+ IIntegrationAttributeSyncCreateParams,+ IIntegrationAttributeSyncRepository,+ IIntegrationAttributeSyncUpdateParams,+} from "./IIntegrationAttributeSyncRepository";++export class PrismaIntegrationAttributeSyncRepository implements IIntegrationAttributeSyncRepository {+ constructor(private readonly prismaClient: PrismaClient) {}++ async getByOrganizationId(organizationId: number) {+ const integrationAttributeSyncQuery = await this.prismaClient.integrationAttributeSync.findMany({+ where: {+ organizationId,+ },+ select: {+ id: true,+ name: true,+ organizationId: true,+ integration: true,+ credentialId: true,+ enabled: true,+ attributeSyncRule: true,+ syncFieldMappings: true,+ },+ });+ return IntegrationAttributeSyncOutputMapper.toDomainList(integrationAttributeSyncQuery);+ }++ async getById(id: string) {+ const integrationAttributeSyncQuery = await this.prismaClient.integrationAttributeSync.findUnique({+ where: {+ id,+ },+ select: {+ id: true,+ name: true,+ organizationId: true,+ integration: true,+ credentialId: true,+ enabled: true,+ attributeSyncRule: true,+ syncFieldMappings: true,+ },+ });++ if (!integrationAttributeSyncQuery) return null;++ return IntegrationAttributeSyncOutputMapper.toDomain(integrationAttributeSyncQuery);+ }++ async getSyncFieldMappings(integrationAttributeSyncId: string) {+ const result = await this.prismaClient.integrationAttributeSync.findUnique({+ where: {+ id: integrationAttributeSyncId,+ },+ select: {+ syncFieldMappings: {+ select: {+ id: true,+ integrationFieldName: true,+ attributeId: true,+ enabled: true,+ },+ },+ },+ });++ return result?.syncFieldMappings || [];+ }++ async getMappedAttributeIdsByOrganization(+ organizationId: number,+ excludeSyncId?: string+ ): Promise<string[]> {+ const result = await this.prismaClient.attributeSyncFieldMapping.findMany({+ where: {+ integrationAttributeSync: {+ organizationId,+ ...(excludeSyncId && { id: { not: excludeSyncId } }),+ },+ },+ select: {+ attributeId: true,+ },+ distinct: ["attributeId"],+ });++ return result.map((r) => r.attributeId);+ }++ async getAttributeIdsByOrganization(organizationId: number, attributeIds: string[]): Promise<string[]> {+ const result = await this.prismaClient.attribute.findMany({+ where: {+ id: { in: attributeIds },+ teamId: organizationId,+ },+ select: { id: true },+ });+ return result.map((r) => r.id);+ }++ async create(params: IIntegrationAttributeSyncCreateParams) {+ const { name, organizationId, integration, credentialId, enabled, rule, syncFieldMappings } = params;++ const created = await this.prismaClient.integrationAttributeSync.create({+ data: {+ name,+ organizationId,+ integration,+ credentialId,+ enabled,+ attributeSyncRule: {+ create: {+ rule: rule as unknown as Prisma.InputJsonValue,+ },+ },+ syncFieldMappings: {+ create: syncFieldMappings.map((mapping) => ({+ integrationFieldName: mapping.integrationFieldName,+ attributeId: mapping.attributeId,+ enabled: mapping.enabled,+ })),+ },+ },+ include: {+ attributeSyncRule: true,+ syncFieldMappings: {+ select: {+ id: true,+ integrationFieldName: true,+ attributeId: true,+ enabled: true,+ },+ },+ },+ });++ return IntegrationAttributeSyncOutputMapper.toDomain(created);+ }++ updateTransactionWithRuleAndMappings(params: IIntegrationAttributeSyncUpdateParams) {+ const {+ integrationAttributeSync,+ attributeSyncRule,+ fieldMappingsToCreate,+ fieldMappingsToUpdate,+ fieldMappingsToDelete,+ } = params;++ const { id: syncId, ...syncData } = integrationAttributeSync;++ return this.prismaClient+ .$transaction([+ this.prismaClient.integrationAttributeSync.update({+ where: {+ id: syncId,+ },+ data: syncData,+ }),+ this.prismaClient.attributeSyncRule.update({+ where: {+ id: attributeSyncRule.id,+ },+ data: {+ rule: attributeSyncRule.rule as unknown as Prisma.InputJsonValue,+ },+ }),+ ...fieldMappingsToUpdate.map(({ id, ...mappingData }) =>+ this.prismaClient.attributeSyncFieldMapping.update({+ where: {+ id,+ },+ data: mappingData,+ })+ ),+ ...(fieldMappingsToCreate.length > 0+ ? [+ this.prismaClient.attributeSyncFieldMapping.createMany({+ data: fieldMappingsToCreate.map((mapping) => ({+ ...mapping,+ integrationAttributeSyncId: syncId,+ })),+ }),+ ]+ : []),+ ...(fieldMappingsToDelete.length > 0+ ? [+ this.prismaClient.attributeSyncFieldMapping.deleteMany({+ where: { id: { in: fieldMappingsToDelete } },+ }),+ ]+ : []),+ ])+ .then(() => {});+ }++ deleteById(id: string) {+ return this.prismaClient.integrationAttributeSync+ .delete({+ where: {+ id,+ },+ })+ .then(() => {});+ }+}diff --git a/packages/features/ee/integration-attribute-sync/schemas/zod.test.ts b/packages/features/ee/integration-attribute-sync/schemas/zod.test.tsnew file mode 100644index 00000000000..71e45559caa--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/schemas/zod.test.ts@@ -0,0 +1,419 @@+import { describe, it, expect } from "vitest";++import {+ attributeSyncRuleConditionSchema,+ attributeSyncRuleSchema,+ syncFormDataSchema,+} from "./zod";++describe("attributeSyncRuleConditionSchema", () => {+ describe("team conditions", () => {+ it("should validate a valid team condition with equals operator", () => {+ const condition = {+ identifier: "teamId",+ operator: "equals",+ value: [1, 2, 3],+ };++ const result = attributeSyncRuleConditionSchema.safeParse(condition);++ expect(result.success).toBe(true);+ if (result.success) {+ expect(result.data).toEqual(condition);+ }+ });++ it("should validate a valid team condition with notEquals operator", () => {+ const condition = {+ identifier: "teamId",+ operator: "notEquals",+ value: [5],+ };++ const result = attributeSyncRuleConditionSchema.safeParse(condition);++ expect(result.success).toBe(true);+ });++ it("should validate a valid team condition with in operator", () => {+ const condition = {+ identifier: "teamId",+ operator: "in",+ value: [1, 2],+ };++ const result = attributeSyncRuleConditionSchema.safeParse(condition);++ expect(result.success).toBe(true);+ });++ it("should validate a valid team condition with notIn operator", () => {+ const condition = {+ identifier: "teamId",+ operator: "notIn",+ value: [3, 4],+ };++ const result = attributeSyncRuleConditionSchema.safeParse(condition);++ expect(result.success).toBe(true);+ });++ it("should reject team condition with string values", () => {+ const condition = {+ identifier: "teamId",+ operator: "equals",+ value: ["team-1", "team-2"],+ };++ const result = attributeSyncRuleConditionSchema.safeParse(condition);++ expect(result.success).toBe(false);+ });++ it("should reject team condition with invalid operator", () => {+ const condition = {+ identifier: "teamId",+ operator: "contains",+ value: [1],+ };++ const result = attributeSyncRuleConditionSchema.safeParse(condition);++ expect(result.success).toBe(false);+ });+ });++ describe("attribute conditions", () => {+ it("should validate a valid attribute condition with equals operator", () => {+ const condition = {+ identifier: "attributeId",+ attributeId: "attr-123",+ operator: "equals",+ value: ["option-1", "option-2"],+ };++ const result = attributeSyncRuleConditionSchema.safeParse(condition);++ expect(result.success).toBe(true);+ if (result.success) {+ expect(result.data).toEqual(condition);+ }+ });++ it("should validate a valid attribute condition with in operator", () => {+ const condition = {+ identifier: "attributeId",+ attributeId: "attr-456",+ operator: "in",+ value: ["opt-a", "opt-b", "opt-c"],+ };++ const result = attributeSyncRuleConditionSchema.safeParse(condition);++ expect(result.success).toBe(true);+ });++ it("should reject attribute condition without attributeId", () => {+ const condition = {+ identifier: "attributeId",+ operator: "equals",+ value: ["option-1"],+ };++ const result = attributeSyncRuleConditionSchema.safeParse(condition);++ expect(result.success).toBe(false);+ });++ it("should reject attribute condition with number values", () => {+ const condition = {+ identifier: "attributeId",+ attributeId: "attr-123",+ operator: "equals",+ value: [1, 2, 3],+ };++ const result = attributeSyncRuleConditionSchema.safeParse(condition);++ expect(result.success).toBe(false);+ });+ });++ describe("invalid conditions", () => {+ it("should reject condition with invalid identifier", () => {+ const condition = {+ identifier: "invalidId",+ operator: "equals",+ value: [1],+ };++ const result = attributeSyncRuleConditionSchema.safeParse(condition);++ expect(result.success).toBe(false);+ });++ it("should reject condition without value", () => {+ const condition = {+ identifier: "teamId",+ operator: "equals",+ };++ const result = attributeSyncRuleConditionSchema.safeParse(condition);++ expect(result.success).toBe(false);+ });+ });+});++describe("attributeSyncRuleSchema", () => {+ it("should validate a rule with AND operator and team conditions", () => {+ const rule = {+ operator: "AND",+ conditions: [+ {+ identifier: "teamId",+ operator: "equals",+ value: [1, 2],+ },+ ],+ };++ const result = attributeSyncRuleSchema.safeParse(rule);++ expect(result.success).toBe(true);+ if (result.success) {+ expect(result.data).toEqual(rule);+ }+ });++ it("should validate a rule with OR operator and attribute conditions", () => {+ const rule = {+ operator: "OR",+ conditions: [+ {+ identifier: "attributeId",+ attributeId: "attr-1",+ operator: "in",+ value: ["opt-1"],+ },+ {+ identifier: "attributeId",+ attributeId: "attr-2",+ operator: "notIn",+ value: ["opt-2"],+ },+ ],+ };++ const result = attributeSyncRuleSchema.safeParse(rule);++ expect(result.success).toBe(true);+ });++ it("should validate a rule with mixed conditions", () => {+ const rule = {+ operator: "AND",+ conditions: [+ {+ identifier: "teamId",+ operator: "equals",+ value: [1],+ },+ {+ identifier: "attributeId",+ attributeId: "attr-1",+ operator: "in",+ value: ["opt-1"],+ },+ ],+ };++ const result = attributeSyncRuleSchema.safeParse(rule);++ expect(result.success).toBe(true);+ });++ it("should validate a rule with empty conditions array", () => {+ const rule = {+ operator: "AND",+ conditions: [],+ };++ const result = attributeSyncRuleSchema.safeParse(rule);++ expect(result.success).toBe(true);+ });++ it("should reject a rule with invalid operator", () => {+ const rule = {+ operator: "XOR",+ conditions: [],+ };++ const result = attributeSyncRuleSchema.safeParse(rule);++ expect(result.success).toBe(false);+ });++ it("should reject a rule without operator", () => {+ const rule = {+ conditions: [],+ };++ const result = attributeSyncRuleSchema.safeParse(rule);++ expect(result.success).toBe(false);+ });++ it("should reject a rule without conditions", () => {+ const rule = {+ operator: "AND",+ };++ const result = attributeSyncRuleSchema.safeParse(rule);++ expect(result.success).toBe(false);+ });+});++describe("syncFormDataSchema", () => {+ const validFormData = {+ id: "sync-123",+ name: "Test Sync",+ credentialId: 1,+ enabled: true,+ organizationId: 123,+ ruleId: "rule-123",+ rule: {+ operator: "AND",+ conditions: [+ {+ identifier: "teamId",+ operator: "equals",+ value: [1],+ },+ ],+ },+ syncFieldMappings: [+ {+ id: "mapping-1",+ integrationFieldName: "field1",+ attributeId: "attr-1",+ enabled: true,+ },+ ],+ };++ it("should validate valid form data with existing mappings", () => {+ const result = syncFormDataSchema.safeParse(validFormData);++ expect(result.success).toBe(true);+ if (result.success) {+ expect(result.data.id).toBe("sync-123");+ expect(result.data.name).toBe("Test Sync");+ }+ });++ it("should validate form data with new mappings (without id)", () => {+ const formData = {+ ...validFormData,+ syncFieldMappings: [+ {+ integrationFieldName: "newField",+ attributeId: "attr-new",+ enabled: false,+ },+ ],+ };++ const result = syncFormDataSchema.safeParse(formData);++ expect(result.success).toBe(true);+ });++ it("should validate form data with mixed new and existing mappings", () => {+ const formData = {+ ...validFormData,+ syncFieldMappings: [+ {+ id: "existing-mapping",+ integrationFieldName: "existingField",+ attributeId: "attr-1",+ enabled: true,+ },+ {+ integrationFieldName: "newField",+ attributeId: "attr-2",+ enabled: false,+ },+ ],+ };++ const result = syncFormDataSchema.safeParse(formData);++ expect(result.success).toBe(true);+ });++ it("should validate form data with empty mappings array", () => {+ const formData = {+ ...validFormData,+ syncFieldMappings: [],+ };++ const result = syncFormDataSchema.safeParse(formData);++ expect(result.success).toBe(true);+ });++ it("should reject form data with empty name", () => {+ const formData = {+ ...validFormData,+ name: "",+ };++ const result = syncFormDataSchema.safeParse(formData);++ expect(result.success).toBe(false);+ });++ it("should reject form data without required fields", () => {+ const formData = {+ name: "Test",+ };++ const result = syncFormDataSchema.safeParse(formData);++ expect(result.success).toBe(false);+ });++ it("should reject form data with invalid rule", () => {+ const formData = {+ ...validFormData,+ rule: {+ operator: "INVALID",+ conditions: [],+ },+ };++ const result = syncFormDataSchema.safeParse(formData);++ expect(result.success).toBe(false);+ });++ it("should reject form data with invalid mapping", () => {+ const formData = {+ ...validFormData,+ syncFieldMappings: [+ {+ integrationFieldName: "field",+ // missing attributeId and enabled+ },+ ],+ };++ const result = syncFormDataSchema.safeParse(formData);++ expect(result.success).toBe(false);+ });+});diff --git a/packages/features/ee/integration-attribute-sync/schemas/zod.ts b/packages/features/ee/integration-attribute-sync/schemas/zod.tsnew file mode 100644index 00000000000..609692cb470--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/schemas/zod.ts@@ -0,0 +1,82 @@+import z from "zod";++import {+ ConditionIdentifierEnum,+ ConditionOperatorEnum,+ type IAttributeSyncRule,+ type IFieldMapping,+ type IFieldMappingFormState,+ type IFieldMappingWithOptionalId,+ type INewFieldMapping,+ type ISyncFormData,+ RuleOperatorEnum,+ type TAttributeSyncRuleCondition,+} from "../repositories/IIntegrationAttributeSyncRepository";++const conditionIdentifierSchema = z.nativeEnum(ConditionIdentifierEnum);+const conditionOperatorSchema = z.nativeEnum(ConditionOperatorEnum);+const ruleOperatorSchema = z.nativeEnum(RuleOperatorEnum);++// Base condition schema+const baseConditionSchema = z.object({+ identifier: conditionIdentifierSchema,+ operator: conditionOperatorSchema,+});++// Team condition schema+const teamConditionSchema = baseConditionSchema.extend({+ identifier: z.literal(ConditionIdentifierEnum.TEAM_ID),+ value: z.array(z.number()),+});++// Attribute condition schema+const attributeConditionSchema = baseConditionSchema.extend({+ identifier: z.literal(ConditionIdentifierEnum.ATTRIBUTE_ID),+ attributeId: z.string(),+ value: z.array(z.string()),+});++// Discriminated union for conditions+export const attributeSyncRuleConditionSchema: z.ZodType<TAttributeSyncRuleCondition> =+ z.discriminatedUnion("identifier", [teamConditionSchema, attributeConditionSchema]);++export const attributeSyncRuleSchema: z.ZodType<IAttributeSyncRule> = z.object({+ operator: ruleOperatorSchema,+ conditions: z.array(attributeSyncRuleConditionSchema),+});++// Define base schema without type annotation to preserve ZodObject methods like .extend()+const _newFieldMappingSchema = z.object({+ integrationFieldName: z.string().min(1),+ attributeId: z.string().min(1),+ enabled: z.boolean(),+});++const _fieldMappingSchema = _newFieldMappingSchema.extend({+ id: z.string(),+});++const _fieldMappingWithOptionalIdSchema = _newFieldMappingSchema.extend({+ id: z.string().optional(),+});++// Cast to ZodType for type safety+export const newFieldMappingSchema: z.ZodType<INewFieldMapping> = _newFieldMappingSchema;+export const fieldMappingSchema: z.ZodType<IFieldMapping> = _fieldMappingSchema;+export const fieldMappingWithOptionalIdSchema: z.ZodType<IFieldMappingWithOptionalId> =+ _fieldMappingWithOptionalIdSchema;++const _fieldMappingFormStateSchema: z.ZodType<IFieldMappingFormState> = z.object({+ mappings: z.array(fieldMappingWithOptionalIdSchema),+});++export const syncFormDataSchema: z.ZodType<ISyncFormData> = z.object({+ id: z.string(),+ name: z.string().min(1, "Name is required"),+ credentialId: z.number().optional(),+ enabled: z.boolean(),+ organizationId: z.number(),+ ruleId: z.string(),+ rule: attributeSyncRuleSchema,+ syncFieldMappings: z.array(z.union([fieldMappingSchema, newFieldMappingSchema])),+});diff --git a/packages/features/ee/integration-attribute-sync/services/IntegrationAttributeSyncService.test.ts b/packages/features/ee/integration-attribute-sync/services/IntegrationAttributeSyncService.test.tsnew file mode 100644index 00000000000..37efeca3824--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/services/IntegrationAttributeSyncService.test.ts@@ -0,0 +1,444 @@+import { describe, it, expect, vi, beforeEach } from "vitest";++import type { CredentialRepository } from "@calcom/features/credentials/repositories/CredentialRepository";++import { enabledAppSlugs } from "../constants";+import type { IIntegrationAttributeSyncRepository } from "../repositories/IIntegrationAttributeSyncRepository";+import { IntegrationAttributeSyncService, UnauthorizedAttributeError } from "./IntegrationAttributeSyncService";++describe("IntegrationAttributeSyncService", () => {+ let service: IntegrationAttributeSyncService;+ let mockCredentialRepository: {+ findByTeamIdAndSlugs: ReturnType<typeof vi.fn>;+ };+ let mockIntegrationAttributeSyncRepository: {+ getByOrganizationId: ReturnType<typeof vi.fn>;+ getById: ReturnType<typeof vi.fn>;+ getSyncFieldMappings: ReturnType<typeof vi.fn>;+ getMappedAttributeIdsByOrganization: ReturnType<typeof vi.fn>;+ getAttributeIdsByOrganization: ReturnType<typeof vi.fn>;+ updateTransactionWithRuleAndMappings: ReturnType<typeof vi.fn>;+ deleteById: ReturnType<typeof vi.fn>;+ };++ beforeEach(() => {+ vi.resetAllMocks();++ mockCredentialRepository = {+ findByTeamIdAndSlugs: vi.fn(),+ };++ mockIntegrationAttributeSyncRepository = {+ getByOrganizationId: vi.fn(),+ getById: vi.fn(),+ getSyncFieldMappings: vi.fn(),+ getMappedAttributeIdsByOrganization: vi.fn(),+ getAttributeIdsByOrganization: vi.fn(),+ updateTransactionWithRuleAndMappings: vi.fn(),+ deleteById: vi.fn(),+ };++ service = new IntegrationAttributeSyncService({+ credentialRepository: mockCredentialRepository as unknown as CredentialRepository,+ integrationAttributeSyncRepository:+ mockIntegrationAttributeSyncRepository as unknown as IIntegrationAttributeSyncRepository,+ });+ });++ describe("getEnabledAppCredentials", () => {+ it("should call credentialRepository.findByTeamIdAndSlugs with correct params", async () => {+ const organizationId = 123;+ const expectedCredentials = [+ { id: 1, type: "salesforce", teamId: organizationId },+ { id: 2, type: "salesforce", teamId: organizationId },+ ];++ mockCredentialRepository.findByTeamIdAndSlugs.mockResolvedValue(expectedCredentials);++ const result = await service.getEnabledAppCredentials(organizationId);++ expect(mockCredentialRepository.findByTeamIdAndSlugs).toHaveBeenCalledWith({+ teamId: organizationId,+ slugs: enabledAppSlugs,+ });+ expect(result).toEqual(expectedCredentials);+ });++ it("should return empty array when no credentials found", async () => {+ const organizationId = 123;+ mockCredentialRepository.findByTeamIdAndSlugs.mockResolvedValue([]);++ const result = await service.getEnabledAppCredentials(organizationId);++ expect(result).toEqual([]);+ });+ });++ describe("getAllIntegrationAttributeSyncs", () => {+ it("should call repository.getByOrganizationId with correct organizationId", async () => {+ const organizationId = 456;+ const expectedSyncs = [+ {+ id: "sync-1",+ name: "Sync 1",+ organizationId,+ integration: "salesforce",+ enabled: true,+ attributeSyncRule: null,+ syncFieldMappings: [],+ },+ ];++ mockIntegrationAttributeSyncRepository.getByOrganizationId.mockResolvedValue(expectedSyncs);++ const result = await service.getAllIntegrationAttributeSyncs(organizationId);++ expect(mockIntegrationAttributeSyncRepository.getByOrganizationId).toHaveBeenCalledWith(organizationId);+ expect(result).toEqual(expectedSyncs);+ });++ it("should return empty array when no syncs found", async () => {+ const organizationId = 456;+ mockIntegrationAttributeSyncRepository.getByOrganizationId.mockResolvedValue([]);++ const result = await service.getAllIntegrationAttributeSyncs(organizationId);++ expect(result).toEqual([]);+ });+ });++ describe("getById", () => {+ it("should call repository.getById with correct id", async () => {+ const syncId = "sync-123";+ const expectedSync = {+ id: syncId,+ name: "Test Sync",+ organizationId: 123,+ integration: "salesforce",+ enabled: true,+ attributeSyncRule: null,+ syncFieldMappings: [],+ };++ mockIntegrationAttributeSyncRepository.getById.mockResolvedValue(expectedSync);++ const result = await service.getById(syncId);++ expect(mockIntegrationAttributeSyncRepository.getById).toHaveBeenCalledWith(syncId);+ expect(result).toEqual(expectedSync);+ });++ it("should return null when sync not found", async () => {+ const syncId = "non-existent";+ mockIntegrationAttributeSyncRepository.getById.mockResolvedValue(null);++ const result = await service.getById(syncId);++ expect(result).toBeNull();+ });+ });++ describe("updateIncludeRulesAndMappings", () => {+ const baseFormData = {+ id: "sync-123",+ name: "Test Sync",+ credentialId: 1,+ enabled: true,+ organizationId: 123,+ ruleId: "rule-123",+ rule: {+ operator: "AND" as const,+ conditions: [+ {+ identifier: "teamId" as const,+ operator: "equals" as const,+ value: [1, 2],+ },+ ],+ },+ };++ it("should create new mappings when they don't have ids", async () => {+ const formData = {+ ...baseFormData,+ syncFieldMappings: [+ { integrationFieldName: "field1", attributeId: "attr-1", enabled: true },+ { integrationFieldName: "field2", attributeId: "attr-2", enabled: false },+ ],+ };++ mockIntegrationAttributeSyncRepository.getMappedAttributeIdsByOrganization.mockResolvedValue([]);+ mockIntegrationAttributeSyncRepository.getAttributeIdsByOrganization.mockResolvedValue(["attr-1", "attr-2"]);+ mockIntegrationAttributeSyncRepository.getSyncFieldMappings.mockResolvedValue([]);+ mockIntegrationAttributeSyncRepository.updateTransactionWithRuleAndMappings.mockResolvedValue(undefined);++ await service.updateIncludeRulesAndMappings(formData);++ expect(mockIntegrationAttributeSyncRepository.updateTransactionWithRuleAndMappings).toHaveBeenCalledWith({+ integrationAttributeSync: {+ id: formData.id,+ name: formData.name,+ credentialId: formData.credentialId,+ enabled: formData.enabled,+ organizationId: formData.organizationId,+ },+ attributeSyncRule: {+ id: formData.ruleId,+ rule: formData.rule,+ },+ fieldMappingsToCreate: formData.syncFieldMappings,+ fieldMappingsToUpdate: [],+ fieldMappingsToDelete: [],+ });+ });++ it("should update existing mappings when they have ids", async () => {+ const formData = {+ ...baseFormData,+ syncFieldMappings: [+ { id: "mapping-1", integrationFieldName: "field1", attributeId: "attr-1", enabled: true },+ { id: "mapping-2", integrationFieldName: "field2", attributeId: "attr-2", enabled: false },+ ],+ };++ mockIntegrationAttributeSyncRepository.getMappedAttributeIdsByOrganization.mockResolvedValue([]);+ mockIntegrationAttributeSyncRepository.getAttributeIdsByOrganization.mockResolvedValue(["attr-1", "attr-2"]);+ mockIntegrationAttributeSyncRepository.getSyncFieldMappings.mockResolvedValue([+ { id: "mapping-1", integrationFieldName: "field1", attributeId: "attr-1", enabled: true },+ { id: "mapping-2", integrationFieldName: "field2", attributeId: "attr-2", enabled: true },+ ]);+ mockIntegrationAttributeSyncRepository.updateTransactionWithRuleAndMappings.mockResolvedValue(undefined);++ await service.updateIncludeRulesAndMappings(formData);++ expect(mockIntegrationAttributeSyncRepository.updateTransactionWithRuleAndMappings).toHaveBeenCalledWith({+ integrationAttributeSync: {+ id: formData.id,+ name: formData.name,+ credentialId: formData.credentialId,+ enabled: formData.enabled,+ organizationId: formData.organizationId,+ },+ attributeSyncRule: {+ id: formData.ruleId,+ rule: formData.rule,+ },+ fieldMappingsToCreate: [],+ fieldMappingsToUpdate: formData.syncFieldMappings,+ fieldMappingsToDelete: [],+ });+ });++ it("should delete mappings that are no longer in the form data", async () => {+ const formData = {+ ...baseFormData,+ syncFieldMappings: [+ { id: "mapping-1", integrationFieldName: "field1", attributeId: "attr-1", enabled: true },+ ],+ };++ mockIntegrationAttributeSyncRepository.getMappedAttributeIdsByOrganization.mockResolvedValue([]);+ mockIntegrationAttributeSyncRepository.getAttributeIdsByOrganization.mockResolvedValue(["attr-1"]);+ mockIntegrationAttributeSyncRepository.getSyncFieldMappings.mockResolvedValue([+ { id: "mapping-1", integrationFieldName: "field1", attributeId: "attr-1", enabled: true },+ { id: "mapping-2", integrationFieldName: "field2", attributeId: "attr-2", enabled: true },+ { id: "mapping-3", integrationFieldName: "field3", attributeId: "attr-3", enabled: true },+ ]);+ mockIntegrationAttributeSyncRepository.updateTransactionWithRuleAndMappings.mockResolvedValue(undefined);++ await service.updateIncludeRulesAndMappings(formData);++ expect(mockIntegrationAttributeSyncRepository.updateTransactionWithRuleAndMappings).toHaveBeenCalledWith({+ integrationAttributeSync: {+ id: formData.id,+ name: formData.name,+ credentialId: formData.credentialId,+ enabled: formData.enabled,+ organizationId: formData.organizationId,+ },+ attributeSyncRule: {+ id: formData.ruleId,+ rule: formData.rule,+ },+ fieldMappingsToCreate: [],+ fieldMappingsToUpdate: [formData.syncFieldMappings[0]],+ fieldMappingsToDelete: ["mapping-2", "mapping-3"],+ });+ });++ it("should handle mixed create, update, and delete operations", async () => {+ const formData = {+ ...baseFormData,+ syncFieldMappings: [+ { id: "mapping-1", integrationFieldName: "field1-updated", attributeId: "attr-1", enabled: false },+ { integrationFieldName: "field-new", attributeId: "attr-new", enabled: true },+ ],+ };++ mockIntegrationAttributeSyncRepository.getMappedAttributeIdsByOrganization.mockResolvedValue([]);+ mockIntegrationAttributeSyncRepository.getAttributeIdsByOrganization.mockResolvedValue(["attr-1", "attr-new"]);+ mockIntegrationAttributeSyncRepository.getSyncFieldMappings.mockResolvedValue([+ { id: "mapping-1", integrationFieldName: "field1", attributeId: "attr-1", enabled: true },+ { id: "mapping-2", integrationFieldName: "field2", attributeId: "attr-2", enabled: true },+ ]);+ mockIntegrationAttributeSyncRepository.updateTransactionWithRuleAndMappings.mockResolvedValue(undefined);++ await service.updateIncludeRulesAndMappings(formData);++ expect(mockIntegrationAttributeSyncRepository.updateTransactionWithRuleAndMappings).toHaveBeenCalledWith({+ integrationAttributeSync: {+ id: formData.id,+ name: formData.name,+ credentialId: formData.credentialId,+ enabled: formData.enabled,+ organizationId: formData.organizationId,+ },+ attributeSyncRule: {+ id: formData.ruleId,+ rule: formData.rule,+ },+ fieldMappingsToCreate: [+ { integrationFieldName: "field-new", attributeId: "attr-new", enabled: true },+ ],+ fieldMappingsToUpdate: [+ { id: "mapping-1", integrationFieldName: "field1-updated", attributeId: "attr-1", enabled: false },+ ],+ fieldMappingsToDelete: ["mapping-2"],+ });+ });++ it("should handle attribute-based conditions in rules", async () => {+ const formData = {+ ...baseFormData,+ rule: {+ operator: "OR" as const,+ conditions: [+ {+ identifier: "attributeId" as const,+ attributeId: "attr-123",+ operator: "in" as const,+ value: ["option-1", "option-2"],+ },+ ],+ },+ syncFieldMappings: [],+ };++ mockIntegrationAttributeSyncRepository.getMappedAttributeIdsByOrganization.mockResolvedValue([]);+ mockIntegrationAttributeSyncRepository.getAttributeIdsByOrganization.mockResolvedValue([]);+ mockIntegrationAttributeSyncRepository.getSyncFieldMappings.mockResolvedValue([]);+ mockIntegrationAttributeSyncRepository.updateTransactionWithRuleAndMappings.mockResolvedValue(undefined);++ await service.updateIncludeRulesAndMappings(formData);++ expect(mockIntegrationAttributeSyncRepository.updateTransactionWithRuleAndMappings).toHaveBeenCalledWith(+ expect.objectContaining({+ attributeSyncRule: {+ id: formData.ruleId,+ rule: formData.rule,+ },+ })+ );+ });+ });++ describe("validateAttributeOwnership", () => {+ const baseFormData = {+ id: "sync-123",+ name: "Test Sync",+ credentialId: 1,+ enabled: true,+ organizationId: 123,+ ruleId: "rule-123",+ rule: {+ operator: "AND" as const,+ conditions: [+ {+ identifier: "teamId" as const,+ operator: "equals" as const,+ value: [1, 2],+ },+ ],+ },+ };++ it("should throw UnauthorizedAttributeError when attribute does not belong to organization", async () => {+ const formData = {+ ...baseFormData,+ syncFieldMappings: [+ { integrationFieldName: "field1", attributeId: "attr-1", enabled: true },+ { integrationFieldName: "field2", attributeId: "attr-invalid", enabled: true },+ ],+ };++ mockIntegrationAttributeSyncRepository.getMappedAttributeIdsByOrganization.mockResolvedValue([]);+ mockIntegrationAttributeSyncRepository.getAttributeIdsByOrganization.mockResolvedValue(["attr-1"]);+ mockIntegrationAttributeSyncRepository.getSyncFieldMappings.mockResolvedValue([]);++ await expect(service.updateIncludeRulesAndMappings(formData)).rejects.toThrow(UnauthorizedAttributeError);+ });++ it("should include invalid attribute ids in the error", async () => {+ const formData = {+ ...baseFormData,+ syncFieldMappings: [+ { integrationFieldName: "field1", attributeId: "attr-valid", enabled: true },+ { integrationFieldName: "field2", attributeId: "attr-invalid-1", enabled: true },+ { integrationFieldName: "field3", attributeId: "attr-invalid-2", enabled: true },+ ],+ };++ mockIntegrationAttributeSyncRepository.getMappedAttributeIdsByOrganization.mockResolvedValue([]);+ mockIntegrationAttributeSyncRepository.getAttributeIdsByOrganization.mockResolvedValue(["attr-valid"]);+ mockIntegrationAttributeSyncRepository.getSyncFieldMappings.mockResolvedValue([]);++ await expect(service.updateIncludeRulesAndMappings(formData)).rejects.toSatisfy((error) => {+ expect(error).toBeInstanceOf(UnauthorizedAttributeError);+ expect((error as UnauthorizedAttributeError).attributeIds).toEqual(["attr-invalid-1", "attr-invalid-2"]);+ return true;+ });+ });++ it("should pass validation when all attributes belong to organization", async () => {+ const formData = {+ ...baseFormData,+ syncFieldMappings: [+ { integrationFieldName: "field1", attributeId: "attr-1", enabled: true },+ { integrationFieldName: "field2", attributeId: "attr-2", enabled: true },+ ],+ };++ mockIntegrationAttributeSyncRepository.getMappedAttributeIdsByOrganization.mockResolvedValue([]);+ mockIntegrationAttributeSyncRepository.getAttributeIdsByOrganization.mockResolvedValue(["attr-1", "attr-2"]);+ mockIntegrationAttributeSyncRepository.getSyncFieldMappings.mockResolvedValue([]);+ mockIntegrationAttributeSyncRepository.updateTransactionWithRuleAndMappings.mockResolvedValue(undefined);++ await expect(service.updateIncludeRulesAndMappings(formData)).resolves.not.toThrow();+ });++ it("should pass validation when syncFieldMappings is empty", async () => {+ const formData = {+ ...baseFormData,+ syncFieldMappings: [],+ };++ mockIntegrationAttributeSyncRepository.getMappedAttributeIdsByOrganization.mockResolvedValue([]);+ mockIntegrationAttributeSyncRepository.getAttributeIdsByOrganization.mockResolvedValue([]);+ mockIntegrationAttributeSyncRepository.getSyncFieldMappings.mockResolvedValue([]);+ mockIntegrationAttributeSyncRepository.updateTransactionWithRuleAndMappings.mockResolvedValue(undefined);++ await expect(service.updateIncludeRulesAndMappings(formData)).resolves.not.toThrow();+ });+ });++ describe("deleteById", () => {+ it("should call repository.deleteById with correct id", async () => {+ const syncId = "sync-to-delete";+ mockIntegrationAttributeSyncRepository.deleteById.mockResolvedValue(undefined);++ await service.deleteById(syncId);++ expect(mockIntegrationAttributeSyncRepository.deleteById).toHaveBeenCalledWith(syncId);+ });+ });+});diff --git a/packages/features/ee/integration-attribute-sync/services/IntegrationAttributeSyncService.ts b/packages/features/ee/integration-attribute-sync/services/IntegrationAttributeSyncService.tsnew file mode 100644index 00000000000..f8ce783bfea--- /dev/null+++ b/packages/features/ee/integration-attribute-sync/services/IntegrationAttributeSyncService.ts@@ -0,0 +1,212 @@+import type { CredentialRepository } from "@calcom/features/credentials/repositories/CredentialRepository";++import type { ZCreateAttributeSyncSchema } from "@calcom/trpc/server/routers/viewer/attribute-sync/createAttributeSync.schema";+import { enabledAppSlugs } from "../constants";+import {+ type IIntegrationAttributeSyncRepository,+ type ISyncFormData,+ AttributeSyncIntegrations,+} from "../repositories/IIntegrationAttributeSyncRepository";+import { attributeSyncRuleSchema } from "../schemas/zod";++export class DuplicateAttributeWithinSyncError extends Error {+ constructor(public attributeId: string) {+ super("Attribute is already mapped in this sync");+ this.name = "DuplicateAttributeWithinSyncError";+ }+}++export class DuplicateAttributeAcrossSyncsError extends Error {+ constructor(public attributeId: string) {+ super("Attribute is already mapped in another sync");+ this.name = "DuplicateAttributeAcrossSyncsError";+ }+}++export class UnauthorizedAttributeError extends Error {+ constructor(public attributeIds: string[]) {+ super("One or more attributes do not belong to this organization");+ this.name = "UnauthorizedAttributeError";+ }+}++export class CredentialNotFoundError extends Error {+ constructor() {+ super("Credential not found");+ this.name = "CredentialNotFoundError";+ }+}++interface IIntegrationAttributeSyncServiceDeps {+ credentialRepository: CredentialRepository;+ integrationAttributeSyncRepository: IIntegrationAttributeSyncRepository;+}++export class IntegrationAttributeSyncService {+ constructor(private readonly deps: IIntegrationAttributeSyncServiceDeps) {}++ private validateWithinSyncUniqueness(+ mappings: { attributeId: string }[]+ ): void {+ const seenAttributes = new Set<string>();+ for (const mapping of mappings) {+ if (seenAttributes.has(mapping.attributeId)) {+ throw new DuplicateAttributeWithinSyncError(mapping.attributeId);+ }+ seenAttributes.add(mapping.attributeId);+ }+ }++ private async validateCrossSyncUniqueness(+ organizationId: number,+ mappings: { attributeId: string }[],+ excludeSyncId?: string+ ): Promise<void> {+ const existingMappedIds =+ await this.deps.integrationAttributeSyncRepository.getMappedAttributeIdsByOrganization(+ organizationId,+ excludeSyncId+ );+ const existingSet = new Set(existingMappedIds);++ for (const mapping of mappings) {+ if (existingSet.has(mapping.attributeId)) {+ throw new DuplicateAttributeAcrossSyncsError(mapping.attributeId);+ }+ }+ }++ private async validateAttributeOwnership(+ organizationId: number,+ attributeIds: string[]+ ): Promise<void> {+ const validAttributeIds =+ await this.deps.integrationAttributeSyncRepository.getAttributeIdsByOrganization(+ organizationId,+ attributeIds+ );++ if (validAttributeIds.length !== attributeIds.length) {+ const validSet = new Set(validAttributeIds);+ const invalidIds = attributeIds.filter((id) => !validSet.has(id));+ throw new UnauthorizedAttributeError(invalidIds);+ }+ }++ async getEnabledAppCredentials(organizationId: number) {+ return this.deps.credentialRepository.findByTeamIdAndSlugs({+ teamId: organizationId,+ slugs: enabledAppSlugs,+ });+ }++ async getAllIntegrationAttributeSyncs(organizationId: number) {+ return this.deps.integrationAttributeSyncRepository.getByOrganizationId(+ organizationId+ );+ }++ async getById(id: string) {+ return this.deps.integrationAttributeSyncRepository.getById(id);+ }++ async createAttributeSync(+ input: ZCreateAttributeSyncSchema,+ organizationId: number+ ) {+ const credential = await this.deps.credentialRepository.findByIdAndTeamId({+ id: input.credentialId,+ teamId: organizationId,+ });++ if (!credential) {+ throw new CredentialNotFoundError();+ }++ const parsedRule = attributeSyncRuleSchema.parse(input.rule);++ const integrationValue = credential.app?.slug || credential.type;+ if (+ !Object.values(AttributeSyncIntegrations).includes(+ integrationValue as AttributeSyncIntegrations+ )+ ) {+ throw new Error(`Unsupported integration type: ${integrationValue}`);+ }++ this.validateWithinSyncUniqueness(input.syncFieldMappings);++ await this.validateCrossSyncUniqueness(+ organizationId,+ input.syncFieldMappings+ );++ const attributeIds = input.syncFieldMappings.map((m) => m.attributeId);+ await this.validateAttributeOwnership(organizationId, attributeIds);++ return this.deps.integrationAttributeSyncRepository.create({+ name: input.name,+ organizationId,+ integration: integrationValue as AttributeSyncIntegrations,+ credentialId: input.credentialId,+ enabled: input.enabled,+ rule: parsedRule,+ syncFieldMappings: input.syncFieldMappings,+ });+ }++ async updateIncludeRulesAndMappings(data: ISyncFormData) {+ const { syncFieldMappings, rule, ruleId, ...integrationAttributeSync } =+ data;++ this.validateWithinSyncUniqueness(syncFieldMappings);++ await this.validateCrossSyncUniqueness(+ data.organizationId,+ syncFieldMappings,+ data.id+ );++ const attributeIds = syncFieldMappings.map((m) => m.attributeId);+ await this.validateAttributeOwnership(data.organizationId, attributeIds);++ const existingFieldMappings =+ await this.deps.integrationAttributeSyncRepository.getSyncFieldMappings(+ data.id+ );++ const parsedRule = attributeSyncRuleSchema.parse(rule);++ const incomingMappingIds = new Set(+ syncFieldMappings.reduce((ids, mapping) => {+ if ("id" in mapping) ids.push(mapping.id);+ return ids;+ }, [] as string[])+ );++ const fieldMappingsToDelete = existingFieldMappings+ .filter((mapping) => !incomingMappingIds.has(mapping.id))+ .map((mapping) => mapping.id);++ const fieldMappingsToCreate = syncFieldMappings.filter((m) => !("id" in m));+ const fieldMappingsToUpdate = syncFieldMappings.filter(+ (m): m is typeof m & { id: string } => "id" in m+ );++ await this.deps.integrationAttributeSyncRepository.updateTransactionWithRuleAndMappings(+ {+ integrationAttributeSync,+ attributeSyncRule: {+ id: ruleId,+ rule: parsedRule,+ },+ fieldMappingsToCreate,+ fieldMappingsToUpdate,+ fieldMappingsToDelete,+ }+ );+ }+ async deleteById(id: string) {+ return this.deps.integrationAttributeSyncRepository.deleteById(id);+ }+}diff --git a/packages/prisma/migrations/20260112172746_add_integration_attribute_sync/migration.sql b/packages/prisma/migrations/20260112172746_add_integration_attribute_sync/migration.sqlnew file mode 100644index 00000000000..8511bf8a36d--- /dev/null+++ b/packages/prisma/migrations/20260112172746_add_integration_attribute_sync/migration.sql@@ -0,0 +1,64 @@+-- CreateTable+CREATE TABLE "public"."IntegrationAttributeSync" (+ "id" TEXT NOT NULL,+ "organizationId" INTEGER NOT NULL,+ "name" TEXT NOT NULL,+ "integration" TEXT NOT NULL,+ "credentialId" INTEGER,+ "enabled" BOOLEAN NOT NULL,+ "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,+ "updatedAt" TIMESTAMP(3) NOT NULL,++ CONSTRAINT "IntegrationAttributeSync_pkey" PRIMARY KEY ("id")+);++-- CreateTable+CREATE TABLE "public"."AttributeSyncRule" (+ "id" TEXT NOT NULL,+ "integrationAttributeSyncId" TEXT NOT NULL,+ "rule" JSONB NOT NULL,+ "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,+ "updatedAt" TIMESTAMP(3) NOT NULL,++ CONSTRAINT "AttributeSyncRule_pkey" PRIMARY KEY ("id")+);++-- CreateTable+CREATE TABLE "public"."AttributeSyncFieldMapping" (+ "id" TEXT NOT NULL,+ "integrationFieldName" TEXT NOT NULL,+ "attributeId" TEXT NOT NULL,+ "enabled" BOOLEAN NOT NULL,+ "integrationAttributeSyncId" TEXT NOT NULL,+ "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,+ "updatedAt" TIMESTAMP(3) NOT NULL,++ CONSTRAINT "AttributeSyncFieldMapping_pkey" PRIMARY KEY ("id")+);++-- CreateIndex+CREATE INDEX "IntegrationAttributeSync_organizationId_idx" ON "public"."IntegrationAttributeSync"("organizationId");++-- CreateIndex+CREATE UNIQUE INDEX "AttributeSyncRule_integrationAttributeSyncId_key" ON "public"."AttributeSyncRule"("integrationAttributeSyncId");++-- CreateIndex+CREATE INDEX "AttributeSyncFieldMapping_integrationAttributeSyncId_idx" ON "public"."AttributeSyncFieldMapping"("integrationAttributeSyncId");++-- CreateIndex+CREATE UNIQUE INDEX "AttributeSyncFieldMapping_integrationAttributeSyncId_attrib_key" ON "public"."AttributeSyncFieldMapping"("integrationAttributeSyncId", "attributeId");++-- AddForeignKey+ALTER TABLE "public"."IntegrationAttributeSync" ADD CONSTRAINT "IntegrationAttributeSync_organizationId_fkey" FOREIGN KEY ("organizationId") REFERENCES "public"."Team"("id") ON DELETE CASCADE ON UPDATE CASCADE;++-- AddForeignKey+ALTER TABLE "public"."IntegrationAttributeSync" ADD CONSTRAINT "IntegrationAttributeSync_credentialId_fkey" FOREIGN KEY ("credentialId") REFERENCES "public"."Credential"("id") ON DELETE CASCADE ON UPDATE CASCADE;++-- AddForeignKey+ALTER TABLE "public"."AttributeSyncRule" ADD CONSTRAINT "AttributeSyncRule_integrationAttributeSyncId_fkey" FOREIGN KEY ("integrationAttributeSyncId") REFERENCES "public"."IntegrationAttributeSync"("id") ON DELETE CASCADE ON UPDATE CASCADE;++-- AddForeignKey+ALTER TABLE "public"."AttributeSyncFieldMapping" ADD CONSTRAINT "AttributeSyncFieldMapping_attributeId_fkey" FOREIGN KEY ("attributeId") REFERENCES "public"."Attribute"("id") ON DELETE CASCADE ON UPDATE CASCADE;++-- AddForeignKey+ALTER TABLE "public"."AttributeSyncFieldMapping" ADD CONSTRAINT "AttributeSyncFieldMapping_integrationAttributeSyncId_fkey" FOREIGN KEY ("integrationAttributeSyncId") REFERENCES "public"."IntegrationAttributeSync"("id") ON DELETE CASCADE ON UPDATE CASCADE;diff --git a/packages/prisma/schema.prisma b/packages/prisma/schema.prismaindex 63a58281ef0..85027b3f20d 100644--- a/packages/prisma/schema.prisma+++ b/packages/prisma/schema.prisma@@ -295,13 +295,14 @@ model Credential {paymentStatus String?billingCycleStart Int?- destinationCalendars DestinationCalendar[]- selectedCalendars SelectedCalendar[]- invalid Boolean? @default(false)- CalendarCache CalendarCache[]- references BookingReference[]- delegationCredentialId String?- delegationCredential DelegationCredential? @relation(fields: [delegationCredentialId], references: [id], onDelete: Cascade)+ destinationCalendars DestinationCalendar[]+ selectedCalendars SelectedCalendar[]+ invalid Boolean? @default(false)+ CalendarCache CalendarCache[]+ references BookingReference[]+ delegationCredentialId String?+ delegationCredential DelegationCredential? @relation(fields: [delegationCredentialId], references: [id], onDelete: Cascade)+ integrationAttributeSyncs IntegrationAttributeSync[]@@index([appId])@@index([subscriptionId])@@ -614,8 +615,9 @@ model Team {managedOrganizations ManagedOrganization[] @relation("ManagerOrganization")filterSegments FilterSegment[]- teamBilling TeamBilling? @relation("TeamBilling")- organizationBilling OrganizationBilling? @relation("OrganizationBilling")+ teamBilling TeamBilling? @relation("TeamBilling")+ organizationBilling OrganizationBilling? @relation("OrganizationBilling")+ integrationAttributeSyncs IntegrationAttributeSync[]autoOptInFeatures Boolean @default(false)@@ -2230,11 +2232,12 @@ model Attribute {usersCanEditRelation Boolean @default(false)- createdAt DateTime @default(now())- updatedAt DateTime @updatedAt- options AttributeOption[]- isWeightsEnabled Boolean @default(false)- isLocked Boolean @default(false)+ createdAt DateTime @default(now())+ updatedAt DateTime @updatedAt+ options AttributeOption[]+ isWeightsEnabled Boolean @default(false)+ isLocked Boolean @default(false)+ attributeSyncFieldMappings AttributeSyncFieldMapping[]@@unique([teamId, slug])@@index([teamId])@@ -3103,3 +3106,54 @@ model CalendarCacheEvent {@@index([start, end, status])@@index([selectedCalendarId, iCalUID])}++model IntegrationAttributeSync {+ id String @id @default(uuid())+ organizationId Int+ organization Team @relation(fields: [organizationId], references: [id], onDelete: Cascade)++ name String+ integration String+ credentialId Int?+ credential Credential? @relation(fields: [credentialId], references: [id], onDelete: Cascade)++ enabled Boolean++ attributeSyncRule AttributeSyncRule?+ syncFieldMappings AttributeSyncFieldMapping[]++ createdAt DateTime @default(now())+ updatedAt DateTime @updatedAt++ @@index([organizationId])+ @@index([credentialId])+}++model AttributeSyncRule {+ id String @id @default(uuid())++ integrationAttributeSyncId String @unique+ integrationAttributeSync IntegrationAttributeSync @relation(fields: [integrationAttributeSyncId], references: [id], onDelete: Cascade)++ rule Json++ createdAt DateTime @default(now())+ updatedAt DateTime @updatedAt+}++model AttributeSyncFieldMapping {+ id String @id @default(uuid())+ integrationFieldName String+ attributeId String+ attribute Attribute @relation(fields: [attributeId], references: [id], onDelete: Cascade)++ enabled Boolean+ integrationAttributeSyncId String+ integrationAttributeSync IntegrationAttributeSync @relation(fields: [integrationAttributeSyncId], references: [id], onDelete: Cascade)++ createdAt DateTime @default(now())+ updatedAt DateTime @updatedAt++ @@unique([integrationAttributeSyncId, attributeId])+ @@index([integrationAttributeSyncId])+}diff --git a/packages/trpc/react/shared.ts b/packages/trpc/react/shared.tsindex 91ef221870c..feeeea73599 100644--- a/packages/trpc/react/shared.ts+++ b/packages/trpc/react/shared.ts@@ -45,4 +45,5 @@ export const ENDPOINTS = ["aiVoiceAgent","phoneNumber","pbac",+ "attributeSync",] as const;diff --git a/packages/trpc/server/routers/viewer/_router.tsx b/packages/trpc/server/routers/viewer/_router.tsxindex 14fda5a5cfc..684b7df6c0d 100644--- a/packages/trpc/server/routers/viewer/_router.tsx+++ b/packages/trpc/server/routers/viewer/_router.tsx@@ -10,6 +10,7 @@ import { aiVoiceAgentRouter } from "./aiVoiceAgent/_router";import { apiKeysRouter } from "./apiKeys/_router";import { appsRouter } from "./apps/_router";import { attributesRouter } from "./attributes/_router";+import { attributeSyncRouter } from "./attribute-sync/_router";import { authRouter } from "./auth/_router";import { availabilityRouter } from "./availability/_router";import { bookingsRouter } from "./bookings/_router";@@ -83,6 +84,7 @@ export const viewerRouter = router({googleWorkspace: googleWorkspaceRouter,admin: adminRouter,attributes: attributesRouter,+ attributeSync: attributeSyncRouter,routingForms: routingFormsRouter,credits: creditsRouter,ooo: oooRouter,diff --git a/packages/trpc/server/routers/viewer/attribute-sync/_router.ts b/packages/trpc/server/routers/viewer/attribute-sync/_router.tsnew file mode 100644index 00000000000..ccdab3d84ba--- /dev/null+++ b/packages/trpc/server/routers/viewer/attribute-sync/_router.ts@@ -0,0 +1,36 @@+import { router } from "../../../trpc";+import { createAttributeSyncSchema } from "./createAttributeSync.schema";+import { deleteAttributeSyncSchema } from "./deleteAttributeSync.schema";+import { getAllAttributeSyncsSchema } from "./getAllAttributeSyncs.schema";+import { updateAttributeSyncSchema } from "./updateAttributeSync.schema";+import { createAttributePbacProcedure } from "./util";++export const attributeSyncRouter = router({+ getAllAttributeSyncs: createAttributePbacProcedure("organization.attributes.read")+ .input(getAllAttributeSyncsSchema)+ .query(async (opts) => {+ const { default: handler } = await import("./getAllAttributeSyncs.handler");+ return handler(opts);+ }),++ createAttributeSync: createAttributePbacProcedure("organization.attributes.create")+ .input(createAttributeSyncSchema)+ .mutation(async (opts) => {+ const { default: handler } = await import("./createAttributeSync.handler");+ return handler(opts);+ }),++ updateAttributeSync: createAttributePbacProcedure("organization.attributes.update")+ .input(updateAttributeSyncSchema)+ .mutation(async (opts) => {+ const { default: handler } = await import("./updateAttributeSync.handler");+ return handler(opts);+ }),++ deleteAttributeSync: createAttributePbacProcedure("organization.attributes.delete")+ .input(deleteAttributeSyncSchema)+ .mutation(async (opts) => {+ const { default: handler } = await import("./deleteAttributeSync.handler");+ return handler(opts);+ }),+});diff --git a/packages/trpc/server/routers/viewer/attribute-sync/createAttributeSync.handler.ts b/packages/trpc/server/routers/viewer/attribute-sync/createAttributeSync.handler.tsnew file mode 100644index 00000000000..0fffe1fd23b--- /dev/null+++ b/packages/trpc/server/routers/viewer/attribute-sync/createAttributeSync.handler.ts@@ -0,0 +1,65 @@+import { getIntegrationAttributeSyncService } from "@calcom/ee/integration-attribute-sync/di/IntegrationAttributeSyncService.container";+import {+ CredentialNotFoundError,+ DuplicateAttributeWithinSyncError,+ DuplicateAttributeAcrossSyncsError,+} from "@calcom/ee/integration-attribute-sync/services/IntegrationAttributeSyncService";++import { TRPCError } from "@trpc/server";++import type { TrpcSessionUser } from "../../../types";+import type { ZCreateAttributeSyncSchema } from "./createAttributeSync.schema";++type CreateAttributeSyncOptions = {+ ctx: {+ user: NonNullable<TrpcSessionUser>;+ };+ input: ZCreateAttributeSyncSchema;+};++const createAttributeSyncHandler = async ({+ ctx,+ input,+}: CreateAttributeSyncOptions) => {+ const org = ctx.user.organization;++ if (!org?.id) {+ throw new TRPCError({+ code: "UNAUTHORIZED",+ message: "You need to be part of an organization to use this feature",+ });+ }++ const integrationAttributeSyncService = getIntegrationAttributeSyncService();++ try {+ return await integrationAttributeSyncService.createAttributeSync(+ input,+ org.id+ );+ } catch (error) {+ if (error instanceof CredentialNotFoundError) {+ throw new TRPCError({+ code: "NOT_FOUND",+ message: "Credential not found",+ });+ }+ if (error instanceof DuplicateAttributeWithinSyncError) {+ throw new TRPCError({+ code: "BAD_REQUEST",+ message:+ "Each attribute can only be mapped once per sync. Please remove duplicate attribute mappings.",+ });+ }+ if (error instanceof DuplicateAttributeAcrossSyncsError) {+ throw new TRPCError({+ code: "BAD_REQUEST",+ message:+ "An attribute is already mapped in another sync. Each attribute can only be synced from one source.",+ });+ }+ throw error;+ }+};++export default createAttributeSyncHandler;diff --git a/packages/trpc/server/routers/viewer/attribute-sync/createAttributeSync.schema.ts b/packages/trpc/server/routers/viewer/attribute-sync/createAttributeSync.schema.tsnew file mode 100644index 00000000000..aba607967a3--- /dev/null+++ b/packages/trpc/server/routers/viewer/attribute-sync/createAttributeSync.schema.ts@@ -0,0 +1,17 @@+import { z } from "zod";++import type { ICreateAttributeSyncInput } from "@calcom/features/ee/integration-attribute-sync/repositories/IIntegrationAttributeSyncRepository";+import {+ attributeSyncRuleSchema,+ newFieldMappingSchema,+} from "@calcom/features/ee/integration-attribute-sync/schemas/zod";++export const createAttributeSyncSchema: z.ZodType<ICreateAttributeSyncInput> = z.object({+ name: z.string().min(1, "Name is required"),+ credentialId: z.number(),+ rule: attributeSyncRuleSchema,+ syncFieldMappings: z.array(newFieldMappingSchema),+ enabled: z.boolean(),+});++export type ZCreateAttributeSyncSchema = ICreateAttributeSyncInput;diff --git a/packages/trpc/server/routers/viewer/attribute-sync/deleteAttributeSync.handler.ts b/packages/trpc/server/routers/viewer/attribute-sync/deleteAttributeSync.handler.tsnew file mode 100644index 00000000000..0507979ad12--- /dev/null+++ b/packages/trpc/server/routers/viewer/attribute-sync/deleteAttributeSync.handler.ts@@ -0,0 +1,29 @@+import { getIntegrationAttributeSyncService } from "@calcom/ee/integration-attribute-sync/di/IntegrationAttributeSyncService.container";++import { TRPCError } from "@trpc/server";++import type { TrpcSessionUser } from "../../../types";+import type { ZDeleteAttributeSyncSchema } from "./deleteAttributeSync.schema";++type DeleteAttributeSyncOptions = {+ ctx: {+ user: NonNullable<TrpcSessionUser>;+ };+ input: ZDeleteAttributeSyncSchema;+};++const deleteAttributeSyncHandler = async ({ ctx, input }: DeleteAttributeSyncOptions) => {+ const currentUserOrgId = ctx.user.organizationId;+ const integrationAttributeSyncService = getIntegrationAttributeSyncService();++ const integrationAttributeSync = await integrationAttributeSyncService.getById(input.id);++ if (!integrationAttributeSync) throw new TRPCError({ code: "NOT_FOUND" });++ if (integrationAttributeSync.organizationId !== currentUserOrgId) {+ throw new TRPCError({ code: "UNAUTHORIZED" });+ }+ await integrationAttributeSyncService.deleteById(input.id);+};++export default deleteAttributeSyncHandler;diff --git a/packages/trpc/server/routers/viewer/attribute-sync/deleteAttributeSync.schema.ts b/packages/trpc/server/routers/viewer/attribute-sync/deleteAttributeSync.schema.tsnew file mode 100644index 00000000000..49df7b00134--- /dev/null+++ b/packages/trpc/server/routers/viewer/attribute-sync/deleteAttributeSync.schema.ts@@ -0,0 +1,7 @@+import { z } from "zod";++export const deleteAttributeSyncSchema = z.object({+ id: z.string(),+});++export type ZDeleteAttributeSyncSchema = z.infer<typeof deleteAttributeSyncSchema>;diff --git a/packages/trpc/server/routers/viewer/attribute-sync/getAllAttributeSyncs.handler.ts b/packages/trpc/server/routers/viewer/attribute-sync/getAllAttributeSyncs.handler.tsnew file mode 100644index 00000000000..ba3627331dc--- /dev/null+++ b/packages/trpc/server/routers/viewer/attribute-sync/getAllAttributeSyncs.handler.ts@@ -0,0 +1,30 @@+import { getIntegrationAttributeSyncService } from "@calcom/features/ee/integration-attribute-sync/di/IntegrationAttributeSyncService.container";++import { TRPCError } from "@trpc/server";++import type { TrpcSessionUser } from "../../../types";+import type { ZGetAllAttributeSyncsSchema } from "./getAllAttributeSyncs.schema";++type GetAllAttributeSyncsOptions = {+ ctx: {+ user: NonNullable<TrpcSessionUser>;+ };+ input: ZGetAllAttributeSyncsSchema;+};++const getAllAttributeSyncsHandler = async ({ ctx }: GetAllAttributeSyncsOptions) => {+ const org = ctx.user.organization;++ if (!org?.id) {+ throw new TRPCError({+ code: "UNAUTHORIZED",+ message: "You need to be part of an organization to use this feature",+ });+ }++ const service = getIntegrationAttributeSyncService();++ return await service.getAllIntegrationAttributeSyncs(org.id);+};++export default getAllAttributeSyncsHandler;diff --git a/packages/trpc/server/routers/viewer/attribute-sync/getAllAttributeSyncs.schema.ts b/packages/trpc/server/routers/viewer/attribute-sync/getAllAttributeSyncs.schema.tsnew file mode 100644index 00000000000..cc6ca0afa6e--- /dev/null+++ b/packages/trpc/server/routers/viewer/attribute-sync/getAllAttributeSyncs.schema.ts@@ -0,0 +1,6 @@+import { z } from "zod";++// No input required - organizationId comes from context+export const getAllAttributeSyncsSchema = z.object({});++export type ZGetAllAttributeSyncsSchema = z.infer<typeof getAllAttributeSyncsSchema>;diff --git a/packages/trpc/server/routers/viewer/attribute-sync/updateAttributeSync.handler.ts b/packages/trpc/server/routers/viewer/attribute-sync/updateAttributeSync.handler.tsnew file mode 100644index 00000000000..c3014bd89da--- /dev/null+++ b/packages/trpc/server/routers/viewer/attribute-sync/updateAttributeSync.handler.ts@@ -0,0 +1,65 @@+import { getIntegrationAttributeSyncService } from "@calcom/ee/integration-attribute-sync/di/IntegrationAttributeSyncService.container";+import {+ DuplicateAttributeWithinSyncError,+ DuplicateAttributeAcrossSyncsError,+} from "@calcom/ee/integration-attribute-sync/services/IntegrationAttributeSyncService";++import { TRPCError } from "@trpc/server";++import type { TrpcSessionUser } from "../../../types";+import { ZUpdateAttributeSyncSchema } from "./updateAttributeSync.schema";++type UpdateAttributeSyncOptions = {+ ctx: {+ user: NonNullable<TrpcSessionUser>;+ };+ input: ZUpdateAttributeSyncSchema;+};++const updateAttributeSyncHandler = async ({+ ctx,+ input,+}: UpdateAttributeSyncOptions) => {+ const org = ctx.user.organization;++ if (!org?.id) {+ throw new TRPCError({+ code: "UNAUTHORIZED",+ message: "You need to be part of an organization to use this feature",+ });+ }++ const integrationAttributeSyncService = getIntegrationAttributeSyncService();++ // Verify the sync exists and belongs to the user's organization+ const integrationAttributeSync =+ await integrationAttributeSyncService.getById(input.id);++ if (!integrationAttributeSync) throw new TRPCError({ code: "NOT_FOUND" });++ if (integrationAttributeSync.organizationId !== org.id) {+ throw new TRPCError({ code: "UNAUTHORIZED" });+ }++ try {+ await integrationAttributeSyncService.updateIncludeRulesAndMappings(input);+ } catch (error) {+ if (error instanceof DuplicateAttributeWithinSyncError) {+ throw new TRPCError({+ code: "BAD_REQUEST",+ message:+ "Each attribute can only be mapped once per sync. Please remove duplicate attribute mappings.",+ });+ }+ if (error instanceof DuplicateAttributeAcrossSyncsError) {+ throw new TRPCError({+ code: "BAD_REQUEST",+ message:+ "This attribute is already mapped in another sync. Each attribute can only be synced from one source.",+ });+ }+ throw error;+ }+};++export default updateAttributeSyncHandler;diff --git a/packages/trpc/server/routers/viewer/attribute-sync/updateAttributeSync.schema.ts b/packages/trpc/server/routers/viewer/attribute-sync/updateAttributeSync.schema.tsnew file mode 100644index 00000000000..57bea8767ab--- /dev/null+++ b/packages/trpc/server/routers/viewer/attribute-sync/updateAttributeSync.schema.ts@@ -0,0 +1,20 @@+import { z } from "zod";++import type { IUpdateAttributeSyncInput } from "@calcom/features/ee/integration-attribute-sync/repositories/IIntegrationAttributeSyncRepository";+import {+ attributeSyncRuleSchema,+ fieldMappingWithOptionalIdSchema,+} from "@calcom/features/ee/integration-attribute-sync/schemas/zod";++export const updateAttributeSyncSchema: z.ZodType<IUpdateAttributeSyncInput> = z.object({+ id: z.string(),+ name: z.string().min(1, "Name is required"),+ credentialId: z.number().optional(),+ enabled: z.boolean(),+ organizationId: z.number(),+ ruleId: z.string(),+ rule: attributeSyncRuleSchema,+ syncFieldMappings: z.array(fieldMappingWithOptionalIdSchema),+});++export type ZUpdateAttributeSyncSchema = IUpdateAttributeSyncInput;diff --git a/packages/trpc/server/routers/viewer/attribute-sync/util.ts b/packages/trpc/server/routers/viewer/attribute-sync/util.tsnew file mode 100644index 00000000000..8d7d8d40771--- /dev/null+++ b/packages/trpc/server/routers/viewer/attribute-sync/util.ts@@ -0,0 +1,2 @@+// Re-export the attribute PBAC procedure for reuse in attribute-sync endpoints+export { createAttributePbacProcedure } from "../attributes/util";diff --git a/packages/trpc/server/routers/viewer/organizations/getTeams.handler.ts b/packages/trpc/server/routers/viewer/organizations/getTeams.handler.tsindex cfe21d91bc3..1366af018a7 100644--- a/packages/trpc/server/routers/viewer/organizations/getTeams.handler.ts+++ b/packages/trpc/server/routers/viewer/organizations/getTeams.handler.ts@@ -1,3 +1,4 @@+import { TeamRepository } from "@calcom/features/ee/teams/repositories/TeamRepository";import { PermissionCheckService } from "@calcom/features/pbac/services/permission-check.service";import { prisma } from "@calcom/prisma";import { MembershipRole } from "@calcom/prisma/enums";@@ -34,10 +35,9 @@ export async function getTeamsHandler({ ctx }: GetTeamsHandler) {});}- const allOrgTeams = await prisma.team.findMany({- where: {- parentId: currentUserOrgId,- },+ const teamRepository = new TeamRepository(prisma);+ const allOrgTeams = await teamRepository.findAllByParentId({+ parentId: currentUserOrgId,select: {id: true,name: true,diff --git a/packages/ui/components/card/FormCard.tsx b/packages/ui/components/card/FormCard.tsxindex f25b794aa1d..b20665e1318 100644--- a/packages/ui/components/card/FormCard.tsx+++ b/packages/ui/components/card/FormCard.tsx@@ -103,6 +103,7 @@ export default function FormCard({badge,collapsible = true,leftIcon,+ customActions,...restProps}: {children: React.ReactNode;@@ -117,6 +118,7 @@ export default function FormCard({badge?: { text: string; href?: string; variant: BadgeProps["variant"] } | null;leftIcon?: IconName;collapsible?: boolean;+ customActions?: React.ReactNode;} & JSX.IntrinsicElements["div"]) {className = classNames("flex items-center group relative w-full rounded-2xl p-1 border border-subtle bg-cal-muted mb-2",@@ -192,7 +194,8 @@ export default function FormCard({</Badge>)}</div>- <div>+ <div className="flex items-center gap-2">+ {customActions}<FormCardActions deleteField={deleteField} duplicateField={duplicateField} /></div></div>