@open-mercato/core 0.9.0 → 0.9.1-develop.7459.1.99e3accd30

package/src/modules/customers/commands/interactions.ts

@@ -50,6 +50,12 @@ import {
 } from '../lib/interactionStatus'
 import { canChangeEmailVisibility } from '../lib/visibilityFilter'
 import { createLogger } from '@open-mercato/shared/lib/logger'
+import { loadCustomFieldDefinitionIndex } from '@open-mercato/shared/lib/crud/custom-fields'
+import type { OrganizationHierarchyService } from '@open-mercato/shared/lib/auth/principal-service'
+import { resolveCatalogEventType, resolveScopedCalendarEventTypes } from '../lib/calendar/eventTypeResolver'
+import { clearInapplicableCoreFields, findInapplicableCoreFields, omitHiddenCoreClears, preserveHiddenCoreValuesOnSameTypeEdit } from '../lib/calendar/interactionApplicability'
+import { calendarEventTypes, type CalendarEventTypeBehavior } from '../calendar-event-types'
+import { canonicalCalendarTimezone } from '../lib/calendar/timezone'
 
 const logger = createLogger('customers')
 
@@ -110,6 +116,7 @@ type InteractionSnapshot = {
     appearanceColor: string | null
     source: string | null
     durationMinutes: number | null
+    timezone?: string | null
     location: string | null
     allDay: boolean | null
     recurrenceRule: string | null
@@ -166,6 +173,7 @@ async function loadInteractionSnapshot(em: EntityManager, id: string): Promise<I
       appearanceColor: interaction.appearanceColor ?? null,
       source: interaction.source ?? null,
       durationMinutes: interaction.durationMinutes ?? null,
+      timezone: interaction.timezone ?? null,
       location: interaction.location ?? null,
       allDay: interaction.allDay ?? null,
       recurrenceRule: interaction.recurrenceRule ?? null,
@@ -199,6 +207,88 @@ async function setInteractionCustomFields(
   })
 }
 
+function requestsSelectableTypeEnforcement(input: unknown): boolean {
+  return input !== null && typeof input === 'object'
+    && 'enforceSelectableType' in input && input.enforceSelectableType === true
+}
+
+async function resolveInteractionTypeBehavior(
+  ctx: CommandRuntimeContext,
+  em: EntityManager,
+  tenantId: string,
+  organizationId: string,
+  key: string,
+  unchangedType: boolean,
+  enforceSelectableType: boolean,
+): Promise<{ behavior: CalendarEventTypeBehavior; organizationIds: string[] }> {
+  const hierarchy = ctx.container.resolve('organizationHierarchyService') as OrganizationHierarchyService
+  const ancestors = await hierarchy.resolveAncestorIds({ tenantId, organizationId })
+  if (ancestors === null) throw notFound('Organization not found')
+  const organizationIds = [organizationId, ...ancestors.slice().reverse()]
+  let catalog
+  try {
+    catalog = await resolveScopedCalendarEventTypes({
+      em,
+      tenantId,
+      organizationId,
+      readableOrganizationIds: organizationIds,
+    })
+  } catch {
+    const { translate } = await resolveTranslations()
+    throw new CrudHttpError(503, {
+      error: translate('customers.calendar.activityTypes.errors.loadFailed', 'Failed to load activity types'),
+      code: 'activity_type_catalog_unavailable',
+      retryable: true,
+    })
+  }
+  const selected = resolveCatalogEventType(catalog, key, { includeHistorical: unchangedType || !enforceSelectableType })
+  if (selected && (unchangedType || !enforceSelectableType || selected.selectable)) {
+    return { behavior: selected.behavior, organizationIds }
+  }
+  if (unchangedType) return { behavior: calendarEventTypes[0]!.behavior, organizationIds }
+  const { translate } = await resolveTranslations()
+  throw new CrudHttpError(400, {
+    error: translate('customers.calendar.activityTypes.errors.unavailable', 'Activity type is unavailable'),
+    code: 'activity_type_unavailable',
+  })
+}
+
+async function loadApplicableCustomFieldKeys(
+  em: EntityManager,
+  tenantId: string,
+  organizationIds: string[],
+  behavior: CalendarEventTypeBehavior,
+): Promise<{ defined: ReadonlySet<string>; allowed: ReadonlySet<string> }> {
+  const options = { em, entityIds: [INTERACTION_ENTITY_ID], tenantId, organizationIds }
+  const all = await loadCustomFieldDefinitionIndex(options)
+  const fieldsets = behavior.customFieldsetIds.map((id) => id === '__general__' ? '' : id)
+  const applicable = fieldsets.length
+    ? await loadCustomFieldDefinitionIndex({ ...options, fieldset: fieldsets })
+    : all
+  return {
+    defined: new Set([...all.keys()].map((key) => key.toLowerCase())),
+    allowed: new Set([...applicable.keys()].map((key) => key.toLowerCase())),
+  }
+}
+
+function inapplicableCustomFieldKeys(
+  values: Readonly<Record<string, unknown>>,
+  keys: { defined: ReadonlySet<string>; allowed: ReadonlySet<string> },
+): string[] {
+  return Object.entries(values)
+    .filter(([key, value]) => keys.defined.has(key.toLowerCase()) && !keys.allowed.has(key.toLowerCase())
+      && value !== null && value !== undefined && value !== '' && (!Array.isArray(value) || value.length > 0))
+    .map(([key]) => key)
+}
+
+function inapplicableFieldError(fields: string[], message: string): CrudHttpError {
+  return new CrudHttpError(400, {
+    error: message,
+    code: 'activity_type_field_not_applicable',
+    fields,
+  })
+}
+
 async function emitLifecycleEvent(
   ctx: CommandRuntimeContext,
   eventId: string,
@@ -259,7 +349,20 @@ function createTransactionalDataEngine(ctx: CommandRuntimeContext, em: EntityMan
 async function runInTransaction<TResult>(
   em: EntityManager,
   operation: (trx: EntityManager) => Promise<TResult>,
+  beforeWrite?: (trx: EntityManager, input?: unknown) => Promise<void>,
+  input?: unknown,
 ): Promise<TResult> {
+  if (typeof em.isInTransaction === 'function' && em.isInTransaction()) {
+    // Joining a caller-owned transaction: this helper neither begins nor commits it,
+    // so the commit boundary — and with it the point the CRUD side effects become
+    // durable — belongs to that caller. The side effects this command emits after
+    // `runInTransaction` returns therefore fire BEFORE the outer commit, unlike the
+    // self-managed branch below. No in-repo caller passes an open transaction today;
+    // a future one must either emit its own side effects after its commit or open a
+    // nested savepoint instead.
+    await beforeWrite?.(em, input)
+    return operation(em)
+  }
   // Mirrors the SPEC-018 fix applied to withAtomicFlush: use explicit begin/commit/rollback
   // so the outer EntityManager stays bound to the transaction, and closures over `em` inside
   // `operation` participate in the same transaction. This avoids the em.transactional(cb)
@@ -274,6 +377,7 @@ async function runInTransaction<TResult>(
   }
   await em.begin()
   try {
+    await beforeWrite?.(em, input)
     const result = await operation(em)
     await em.commit()
     return result
@@ -328,6 +432,7 @@ type InteractionGraphValues = {
   appearanceIcon: string | null
   appearanceColor: string | null
   durationMinutes: number | null
+  timezone: string | null
   location: string | null
   allDay: boolean | null
   recurrenceRule: string | null
@@ -364,6 +469,7 @@ function buildInteractionGraph(em: EntityManager, values: InteractionGraphValues
     appearanceIcon: values.appearanceIcon,
     appearanceColor: values.appearanceColor,
     durationMinutes: values.durationMinutes,
+    timezone: values.timezone ?? null,
     location: values.location,
     allDay: values.allDay,
     recurrenceRule: values.recurrenceRule,
@@ -383,7 +489,7 @@ const createInteractionCommand: CommandHandler<InteractionCreateInput, { interac
   async execute(rawInput, ctx) {
     const { parsed, custom } = parseWithCustomFields(interactionCreateSchema, rawInput)
 
-    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const em = ctx.transactionalEm ?? (ctx.container.resolve('em') as EntityManager).fork()
     const normalizedAuthor = normalizeAuthorUserId(parsed.authorUserId ?? null, ctx.auth)
     const { interaction, entityId, nextInteractionId } = await runInTransaction(em, async (trx) => {
       const entity = await requireTimelineParentEntity(trx, parsed.entityId, { tenantId: parsed.tenantId, organizationId: parsed.organizationId })
@@ -394,6 +500,23 @@ const createInteractionCommand: CommandHandler<InteractionCreateInput, { interac
         await requireDealInScope(trx, parsed.dealId, entity.tenantId, entity.organizationId)
       }
 
+      const enforceSelectableType = requestsSelectableTypeEnforcement(rawInput)
+      const { behavior, organizationIds } = await resolveInteractionTypeBehavior(
+        ctx, trx, entity.tenantId, entity.organizationId, parsed.interactionType, false, enforceSelectableType,
+      )
+      const inapplicableCore = findInapplicableCoreFields(behavior, parsed)
+      const customKeys = Object.keys(custom).length
+        ? await loadApplicableCustomFieldKeys(trx, entity.tenantId, organizationIds, behavior)
+        : null
+      const inapplicableCustom = customKeys ? inapplicableCustomFieldKeys(custom, customKeys) : []
+      if (enforceSelectableType && (inapplicableCore.length || inapplicableCustom.length)) {
+        const { translate } = await resolveTranslations()
+        throw inapplicableFieldError(
+          [...inapplicableCore, ...inapplicableCustom.map((key) => `cf_${key}`)],
+          translate('customers.calendar.activityTypes.errors.fieldNotApplicable', 'Field is not applicable to this activity type'),
+        )
+      }
+
       const interaction = buildInteractionGraph(trx, {
         ...(parsed.id ? { id: parsed.id } : {}),
         organizationId: entity.organizationId,
@@ -413,6 +536,7 @@ const createInteractionCommand: CommandHandler<InteractionCreateInput, { interac
         appearanceIcon: parsed.appearanceIcon ?? null,
         appearanceColor: parsed.appearanceColor ?? null,
         durationMinutes: parsed.durationMinutes ?? null,
+        timezone: canonicalCalendarTimezone(parsed.timezone) ?? null,
         location: parsed.location ?? null,
         allDay: parsed.allDay ?? null,
         recurrenceRule: parsed.recurrenceRule ?? null,
@@ -441,7 +565,7 @@ const createInteractionCommand: CommandHandler<InteractionCreateInput, { interac
         entityId: entity.id,
         nextInteractionId: projection.nextInteractionId,
       }
-    })
+    }, ctx.beforeTransactionalWrite, rawInput)
 
     const de = (ctx.container.resolve('dataEngine') as DataEngine)
     await emitCrudSideEffects({
@@ -466,7 +590,7 @@ const createInteractionCommand: CommandHandler<InteractionCreateInput, { interac
     return { interactionId: interaction.id, entityId }
   },
   captureAfter: async (_input, result, ctx) => {
-    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const em = ctx.transactionalEm ?? (ctx.container.resolve('em') as EntityManager).fork()
     return await loadInteractionSnapshot(em, result.interactionId)
   },
   buildLog: async ({ result, snapshots }) => {
@@ -544,6 +668,7 @@ const createInteractionCommand: CommandHandler<InteractionCreateInput, { interac
           appearanceIcon: after.interaction.appearanceIcon,
           appearanceColor: after.interaction.appearanceColor,
           durationMinutes: after.interaction.durationMinutes,
+          timezone: after.interaction.timezone ?? null,
           location: after.interaction.location,
           allDay: after.interaction.allDay,
           recurrenceRule: after.interaction.recurrenceRule,
@@ -572,6 +697,7 @@ const createInteractionCommand: CommandHandler<InteractionCreateInput, { interac
         interaction.appearanceIcon = after.interaction.appearanceIcon
         interaction.appearanceColor = after.interaction.appearanceColor
         interaction.durationMinutes = after.interaction.durationMinutes
+        interaction.timezone = after.interaction.timezone ?? null
         interaction.location = after.interaction.location
         interaction.allDay = after.interaction.allDay
         interaction.recurrenceRule = after.interaction.recurrenceRule
@@ -631,17 +757,20 @@ const createInteractionCommand: CommandHandler<InteractionCreateInput, { interac
 
 // ─── Update ─────────────────────────────────────────────────────────
 
+async function prepareUpdateInteractionSnapshot(rawInput: InteractionUpdateInput, ctx: CommandRuntimeContext) {
+  const { parsed } = parseWithCustomFields(interactionUpdateSchema, rawInput)
+  const em = ctx.transactionalEm ?? (ctx.container.resolve('em') as EntityManager).fork()
+  const snapshot = await loadInteractionSnapshot(em, parsed.id)
+  return snapshot ? { before: snapshot } : {}
+}
+
 const updateInteractionCommand: CommandHandler<InteractionUpdateInput, { interactionId: string }> = {
   id: 'customers.interactions.update',
-  async prepare(rawInput, ctx) {
-    const { parsed } = parseWithCustomFields(interactionUpdateSchema, rawInput)
-    const em = (ctx.container.resolve('em') as EntityManager).fork()
-    const snapshot = await loadInteractionSnapshot(em, parsed.id)
-    return snapshot ? { before: snapshot } : {}
-  },
+  prepare: prepareUpdateInteractionSnapshot,
+  prepareSnapshotInsideTransaction: true,
   async execute(rawInput, ctx) {
     const { parsed, custom } = parseWithCustomFields(interactionUpdateSchema, rawInput)
-    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const em = ctx.transactionalEm ?? (ctx.container.resolve('em') as EntityManager).fork()
     const { interaction, projections } = await runInTransaction(em, async (trx) => {
       const interaction = await findOneWithDecryption(trx, CustomerInteraction, { id: parsed.id, deletedAt: null })
       if (!interaction) {
@@ -663,6 +792,84 @@ const updateInteractionCommand: CommandHandler<InteractionUpdateInput, { interac
         request: ctx.request ?? null,
       })
 
+      const nextType = parsed.interactionType ?? interaction.interactionType
+      const changingType = nextType !== interaction.interactionType
+      const enforceSelectableType = requestsSelectableTypeEnforcement(rawInput)
+      const { behavior, organizationIds } = await resolveInteractionTypeBehavior(
+        ctx, trx, interaction.tenantId, interaction.organizationId, nextType, !changingType, enforceSelectableType,
+      )
+      const currentCoreValues = {
+        durationMinutes: interaction.durationMinutes,
+        timezone: interaction.timezone ?? null,
+        allDay: interaction.allDay,
+        recurrenceRule: interaction.recurrenceRule,
+        recurrenceEnd: interaction.recurrenceEnd,
+        location: interaction.location,
+        participants: interaction.participants,
+        priority: interaction.priority,
+        linkedEntities: interaction.linkedEntities,
+      }
+      const typeChangeFields = changingType && enforceSelectableType ? omitHiddenCoreClears(behavior, parsed) : parsed
+      const coreValues = { ...currentCoreValues, ...typeChangeFields }
+      const inapplicableCore = findInapplicableCoreFields(behavior, changingType ? coreValues : parsed)
+      const confirmsDiscard = parsed.confirmDiscardInapplicableValues === true
+      const currentCustom = changingType && (enforceSelectableType || confirmsDiscard)
+        ? await loadCustomFieldSnapshot(trx, {
+          entityId: INTERACTION_ENTITY_ID,
+          recordId: interaction.id,
+          tenantId: interaction.tenantId,
+          organizationId: interaction.organizationId,
+        })
+        : {}
+      const customValues = changingType ? { ...currentCustom, ...custom } : custom
+      const customKeys = Object.keys(customValues).length
+        ? await loadApplicableCustomFieldKeys(trx, interaction.tenantId, organizationIds, behavior)
+        : null
+      const inapplicableCustom = customKeys ? inapplicableCustomFieldKeys(customValues, customKeys) : []
+      if (!changingType && enforceSelectableType && (inapplicableCore.length || inapplicableCustom.length)) {
+        const { translate } = await resolveTranslations()
+        throw inapplicableFieldError(
+          [...inapplicableCore, ...inapplicableCustom.map((key) => `cf_${key}`)],
+          translate('customers.calendar.activityTypes.errors.fieldNotApplicable', 'Field is not applicable to this activity type'),
+        )
+      }
+      if (changingType && enforceSelectableType && (inapplicableCore.length || inapplicableCustom.length) && !confirmsDiscard) {
+        const { translate } = await resolveTranslations()
+        throw new CrudHttpError(409, {
+          error: translate('customers.calendar.activityTypes.errors.changeConfirmationRequired', 'Changing type will clear existing values'),
+          code: 'calendar_type_change_confirmation_required',
+          fields: [...inapplicableCore, ...inapplicableCustom.map((key) => `cf_${key}`)],
+        })
+      }
+      // The type-change 409 is scoped to the selectable-type opt-in, and stored
+      // values are cleared only on an explicit `confirmDiscardInapplicableValues`.
+      // A legacy caller (the schedule dialog, the deal composer, the kanban quick
+      // actions, a direct API client) sends a partial payload and does not handle
+      // the 409, so judging it on the merged stored row rejected switches it has
+      // always been able to make — e.g. a Task carrying a priority becoming a
+      // Meeting. Those callers keep the pre-catalog behavior exactly: the fields
+      // they sent are written and nothing stored is cleared, even when the new
+      // type cannot display it.
+      const discardsInapplicableValues = changingType && confirmsDiscard
+      const clearedCore = discardsInapplicableValues
+        ? clearInapplicableCoreFields(behavior, coreValues)
+        : {}
+      const clearedCustom = discardsInapplicableValues
+        ? Object.fromEntries(inapplicableCustom.map((key) => [key, Array.isArray(customValues[key]) ? [] : null]))
+        : {}
+      // Narrowing a same-type edit (ignoring explicit clears of hidden core fields,
+      // dropping custom fields outside the type's fieldsets) is part of the opt-in
+      // contract too: a legacy caller's write is accepted as sent.
+      const sameTypeFields = changingType
+        ? typeChangeFields
+        : preserveHiddenCoreValuesOnSameTypeEdit(behavior, currentCoreValues, parsed, {
+          ignoreHiddenClears: enforceSelectableType,
+        })
+      const sameTypeCustom = changingType || !customKeys || !enforceSelectableType
+        ? custom
+        : Object.fromEntries(Object.entries(custom).filter(([key]) =>
+          !customKeys.defined.has(key.toLowerCase()) || customKeys.allowed.has(key.toLowerCase())))
+
       // Email visibility is an access-controlled field: only the interaction's
       // author may change a
       // private email's visibility (mirrors the dedicated PATCH .../visibility
@@ -718,24 +925,36 @@ const updateInteractionCommand: CommandHandler<InteractionUpdateInput, { interac
       if (parsed.body !== undefined) interaction.body = parsed.body ?? null
       if (parsed.status !== undefined) interaction.status = parsed.status
       if (parsed.scheduledAt !== undefined) interaction.scheduledAt = parsed.scheduledAt ?? null
+      if (parsed.timezone !== undefined) interaction.timezone = canonicalCalendarTimezone(parsed.timezone) ?? null
       if (parsed.occurredAt !== undefined) interaction.occurredAt = parsed.occurredAt ?? null
-      if (parsed.priority !== undefined) interaction.priority = parsed.priority ?? null
+      if (sameTypeFields.priority !== undefined) interaction.priority = sameTypeFields.priority as number | null
       if (parsed.authorUserId !== undefined) interaction.authorUserId = parsed.authorUserId ?? null
       if (parsed.ownerUserId !== undefined) interaction.ownerUserId = parsed.ownerUserId ?? null
       if (parsed.appearanceIcon !== undefined) interaction.appearanceIcon = parsed.appearanceIcon ?? null
       if (parsed.appearanceColor !== undefined) interaction.appearanceColor = parsed.appearanceColor ?? null
       if (parsed.pinned !== undefined) interaction.pinned = parsed.pinned
-      if (parsed.durationMinutes !== undefined) interaction.durationMinutes = parsed.durationMinutes ?? null
-      if (parsed.location !== undefined) interaction.location = parsed.location ?? null
-      if (parsed.allDay !== undefined) interaction.allDay = parsed.allDay ?? null
-      if (parsed.recurrenceRule !== undefined) interaction.recurrenceRule = parsed.recurrenceRule ?? null
-      if (parsed.recurrenceEnd !== undefined) interaction.recurrenceEnd = parsed.recurrenceEnd ?? null
-      if (parsed.participants !== undefined) interaction.participants = parsed.participants ?? null
+      if (sameTypeFields.durationMinutes !== undefined) interaction.durationMinutes = sameTypeFields.durationMinutes as number | null
+      if (sameTypeFields.location !== undefined) interaction.location = sameTypeFields.location as string | null
+      if (sameTypeFields.allDay !== undefined) interaction.allDay = sameTypeFields.allDay as boolean | null
+      if (sameTypeFields.recurrenceRule !== undefined) interaction.recurrenceRule = sameTypeFields.recurrenceRule as string | null
+      if (sameTypeFields.recurrenceEnd !== undefined) interaction.recurrenceEnd = sameTypeFields.recurrenceEnd as Date | null
+      if (sameTypeFields.participants !== undefined) interaction.participants = sameTypeFields.participants as InteractionSnapshot['interaction']['participants']
       if (parsed.reminderMinutes !== undefined) interaction.reminderMinutes = parsed.reminderMinutes ?? null
       if (parsed.visibility !== undefined) interaction.visibility = parsed.visibility ?? null
-      if (parsed.linkedEntities !== undefined) interaction.linkedEntities = parsed.linkedEntities ?? null
+      if (sameTypeFields.linkedEntities !== undefined) interaction.linkedEntities = sameTypeFields.linkedEntities as InteractionSnapshot['interaction']['linkedEntities']
       if (parsed.guestPermissions !== undefined) interaction.guestPermissions = parsed.guestPermissions ?? null
 
+      for (const [field, value] of Object.entries(clearedCore)) {
+        if (field === 'linkedEntities') interaction.linkedEntities = value as InteractionSnapshot['interaction']['linkedEntities']
+        else if (field === 'durationMinutes') interaction.durationMinutes = null
+        else if (field === 'allDay') interaction.allDay = null
+        else if (field === 'recurrenceRule') interaction.recurrenceRule = null
+        else if (field === 'recurrenceEnd') interaction.recurrenceEnd = null
+        else if (field === 'location') interaction.location = null
+        else if (field === 'participants') interaction.participants = null
+        else if (field === 'priority') interaction.priority = null
+      }
+
       await trx.flush()
 
       const entityId = typeof interaction.entity === 'string' ? interaction.entity : interaction.entity.id
@@ -744,7 +963,7 @@ const updateInteractionCommand: CommandHandler<InteractionUpdateInput, { interac
         interaction.id,
         interaction.organizationId,
         interaction.tenantId,
-        custom,
+        { ...sameTypeCustom, ...clearedCustom },
       )
 
       const projection = await recomputeNextInteraction(trx, entityId)
@@ -760,7 +979,7 @@ const updateInteractionCommand: CommandHandler<InteractionUpdateInput, { interac
       }
 
       return { interaction, projections }
-    })
+    }, ctx.beforeTransactionalWrite, rawInput)
 
     const de = (ctx.container.resolve('dataEngine') as DataEngine)
     await emitCrudSideEffects({
@@ -787,7 +1006,7 @@ const updateInteractionCommand: CommandHandler<InteractionUpdateInput, { interac
     return { interactionId: interaction.id }
   },
   captureAfter: async (_input, result, ctx) => {
-    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const em = ctx.transactionalEm ?? (ctx.container.resolve('em') as EntityManager).fork()
     return await loadInteractionSnapshot(em, result.interactionId)
   },
   buildLog: async ({ snapshots }) => {
@@ -842,6 +1061,7 @@ const updateInteractionCommand: CommandHandler<InteractionUpdateInput, { interac
           appearanceIcon: before.interaction.appearanceIcon,
           appearanceColor: before.interaction.appearanceColor,
           durationMinutes: before.interaction.durationMinutes,
+          timezone: before.interaction.timezone ?? null,
           location: before.interaction.location,
           allDay: before.interaction.allDay,
           recurrenceRule: before.interaction.recurrenceRule,
@@ -871,6 +1091,7 @@ const updateInteractionCommand: CommandHandler<InteractionUpdateInput, { interac
         interaction.appearanceIcon = before.interaction.appearanceIcon
         interaction.appearanceColor = before.interaction.appearanceColor
         interaction.durationMinutes = before.interaction.durationMinutes
+        interaction.timezone = before.interaction.timezone ?? null
         interaction.location = before.interaction.location
         interaction.allDay = before.interaction.allDay
         interaction.recurrenceRule = before.interaction.recurrenceRule
@@ -1322,6 +1543,7 @@ const deleteInteractionCommand: CommandHandler<{ body?: Record<string, unknown>;
             appearanceIcon: before.interaction.appearanceIcon,
             appearanceColor: before.interaction.appearanceColor,
             durationMinutes: before.interaction.durationMinutes,
+            timezone: before.interaction.timezone ?? null,
             location: before.interaction.location,
             allDay: before.interaction.allDay,
             recurrenceRule: before.interaction.recurrenceRule,
@@ -1352,6 +1574,7 @@ const deleteInteractionCommand: CommandHandler<{ body?: Record<string, unknown>;
           interaction.appearanceIcon = before.interaction.appearanceIcon
           interaction.appearanceColor = before.interaction.appearanceColor
           interaction.durationMinutes = before.interaction.durationMinutes
+          interaction.timezone = before.interaction.timezone ?? null
           interaction.location = before.interaction.location
           interaction.allDay = before.interaction.allDay
           interaction.recurrenceRule = before.interaction.recurrenceRule