@open-mercato/core 0.6.3-develop.3651.1.d3a548a5f1 → 0.6.3-develop.3653.1.b8558737ae

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

@@ -554,6 +554,17 @@ const updateDealCommand: CommandHandler<DealUpdateInput, { dealId: string }> = {
         if (parsed.lossReasonId !== undefined) record.lossReasonId = parsed.lossReasonId ?? null
         if (parsed.lossNotes !== undefined) record.lossNotes = parsed.lossNotes ?? null
       },
+      async () => {
+        // CRITICAL: persist the scalar mutations above before any further `em.findOne` / sync
+        // helpers run inside this transaction. MikroORM v7's identity-map silently discards
+        // pending scalar changes on `record` if a query (such as the stage-transition lookup
+        // inside `upsertDealStageTransition`, or the linked-entity finds inside
+        // `syncDealPeople` / `syncDealCompanies`) executes on the same `EntityManager`
+        // before we explicitly flush. Without this flush, the entire kanban drag-and-drop
+        // returns 200 OK but never actually updates `customer_deals` rows — the card
+        // snaps back to its source lane on the next refetch (see SPEC-018).
+        await em.flush()
+      },
       async () => {
         const snapshot = nextStageSnapshot
         if (!snapshot) return
@@ -715,6 +726,14 @@ const updateDealCommand: CommandHandler<DealUpdateInput, { dealId: string }> = {
         deal.lossReasonId = before.deal.lossReasonId
         deal.lossNotes = before.deal.lossNotes
       },
+      async () => {
+        // Mirror of the fix applied to the forward `execute` path: persist the scalar
+        // mutations on `deal` before any further `em.findOne` (the transition lookup
+        // inside `upsertDealStageTransition`) or sync-helper queries run on the same EM.
+        // MikroORM v7 silently discards the pending scalar changes if we don't flush here
+        // (see SPEC-018), which would make an undo of a kanban stage move silently no-op.
+        await em.flush()
+      },
       async () => {
         if (!shouldRecordRevertTransition || !before.deal.pipelineStageId) return
         const pipelineId = revertedStageSnapshot?.pipelineId ?? before.deal.pipelineId ?? existingTransition?.pipelineId

package/src/modules/customers/commands/pipeline-stages.ts

@@ -1,6 +1,7 @@
 import { registerCommand } from '@open-mercato/shared/lib/commands'
 import type { CommandHandler } from '@open-mercato/shared/lib/commands'
 import type { EntityManager } from '@mikro-orm/postgresql'
+import { findOneWithDecryption, findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
 import { CustomerPipelineStage, CustomerDeal } from '../data/entities'
 import {
   pipelineStageCreateSchema,
@@ -24,18 +25,49 @@ const createPipelineStageCommand: CommandHandler<PipelineStageCreateInput, { sta
 
     const em = (ctx.container.resolve('em') as EntityManager).fork()
 
-    const existingCount = await em.count(CustomerPipelineStage, {
-      organizationId: parsed.organizationId,
-      tenantId: parsed.tenantId,
-      pipelineId: parsed.pipelineId,
-    })
+    // Load the full ordered list once. We need it both to know where "end" is and to
+    // shift any stages that occupy positions at or after the chosen insert point.
+    const existingStages = await findWithDecryption(
+      em,
+      CustomerPipelineStage,
+      {
+        organizationId: parsed.organizationId,
+        tenantId: parsed.tenantId,
+        pipelineId: parsed.pipelineId,
+      },
+      { orderBy: { order: 'ASC' } },
+      { tenantId: parsed.tenantId, organizationId: parsed.organizationId },
+    )
+
+    // Clamp the requested insert position into the legal range [0, length]. Anything
+    // outside that range (negative, way past the end) collapses to "append" so we never
+    // create stages that hop the visible board boundary.
+    const requestedOrder = parsed.order
+    const insertOrder =
+      requestedOrder === undefined
+        ? existingStages.length
+        : Math.max(0, Math.min(requestedOrder, existingStages.length))
+
+    // Shift the order of every stage at or after the insert position. We use the
+    // already-forked EM so the shifts and the new INSERT land in a single `flush()`
+    // (one transaction by default with MikroORM's `forceTransactions` config). Skipping
+    // this step would either duplicate `order` values (silently corrupting kanban
+    // ordering) or push the new stage to the wrong spot when re-sorting.
+    if (requestedOrder !== undefined) {
+      for (const stage of existingStages) {
+        if (stage.order >= insertOrder) {
+          stage.order += 1
+          stage.updatedAt = new Date()
+        }
+      }
+    }
 
     const stage = em.create(CustomerPipelineStage, {
       organizationId: parsed.organizationId,
       tenantId: parsed.tenantId,
       pipelineId: parsed.pipelineId,
       label: parsed.label,
-      order: parsed.order ?? existingCount,
+      order: insertOrder,
       createdAt: new Date(),
       updatedAt: new Date(),
     })
@@ -61,8 +93,17 @@ const updatePipelineStageCommand: CommandHandler<PipelineStageUpdateInput, void>
   async execute(rawInput, ctx) {
     const parsed = pipelineStageUpdateSchema.parse(rawInput)
 
+    // Restrict the lookup to the caller's tenant/organization scope so a
+    // wrong-tenant id returns 404 (same as a missing row), not 403 — avoids
+    // leaking existence of stages outside the caller's scope.
+    const callerTenantId = ctx.auth?.tenantId ?? null
+    const callerOrganizationId = ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? null
     const em = (ctx.container.resolve('em') as EntityManager).fork()
-    const stage = await em.findOne(CustomerPipelineStage, { id: parsed.id })
+    const stage = await findOneWithDecryption(em, CustomerPipelineStage, {
+      id: parsed.id,
+      ...(callerTenantId ? { tenantId: callerTenantId } : {}),
+      ...(callerOrganizationId ? { organizationId: callerOrganizationId } : {}),
+    })
     if (!stage) throw new CrudHttpError(404, { error: 'Pipeline stage not found' })
 
     ensureTenantScope(ctx, stage.tenantId)
@@ -93,8 +134,16 @@ const deletePipelineStageCommand: CommandHandler<PipelineStageDeleteInput, void>
   async execute(rawInput, ctx) {
     const parsed = pipelineStageDeleteSchema.parse(rawInput)
 
+    // See update command above — scope the lookup to the caller's tenant/org so a
+    // cross-tenant id returns 404, not 403.
+    const callerTenantId = ctx.auth?.tenantId ?? null
+    const callerOrganizationId = ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? null
     const em = (ctx.container.resolve('em') as EntityManager).fork()
-    const stage = await em.findOne(CustomerPipelineStage, { id: parsed.id })
+    const stage = await findOneWithDecryption(em, CustomerPipelineStage, {
+      id: parsed.id,
+      ...(callerTenantId ? { tenantId: callerTenantId } : {}),
+      ...(callerOrganizationId ? { organizationId: callerOrganizationId } : {}),
+    })
     if (!stage) throw new CrudHttpError(404, { error: 'Pipeline stage not found' })
 
     ensureTenantScope(ctx, stage.tenantId)
@@ -123,11 +172,17 @@ const reorderPipelineStagesCommand: CommandHandler<PipelineStageReorderInput, vo
     const em = (ctx.container.resolve('em') as EntityManager).fork()
 
     const ids = parsed.stages.map((s) => s.id)
-    const stages = await em.find(CustomerPipelineStage, {
-      id: { $in: ids },
-      organizationId: parsed.organizationId,
-      tenantId: parsed.tenantId,
-    })
+    const stages = await findWithDecryption(
+      em,
+      CustomerPipelineStage,
+      {
+        id: { $in: ids },
+        organizationId: parsed.organizationId,
+        tenantId: parsed.tenantId,
+      },
+      undefined,
+      { tenantId: parsed.tenantId, organizationId: parsed.organizationId },
+    )
 
     const stageMap = new Map<string, CustomerPipelineStage>()
     stages.forEach((stage) => stageMap.set(stage.id, stage))

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

@@ -1,18 +1,38 @@
 import { registerCommand } from '@open-mercato/shared/lib/commands'
 import type { CommandHandler } from '@open-mercato/shared/lib/commands'
 import type { EntityManager } from '@mikro-orm/postgresql'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
 import { CustomerSettings, type CustomerAddressFormat } from '../data/entities'
-import { customerSettingsUpsertSchema, type CustomerSettingsUpsertInput } from '../data/validators'
+import {
+  customerSettingsUpsertSchema,
+  customerStuckThresholdUpsertSchema,
+  type CustomerSettingsUpsertInput,
+  type CustomerStuckThresholdUpsertInput,
+} from '../data/validators'
 import { ensureOrganizationScope, ensureTenantScope } from './shared'
 
+/**
+ * Tenant-scoped settings lookup. `CustomerSettings` carries no encrypted columns today
+ * (just enum + int scalars + scope/timestamps), so `findOneWithDecryption` is effectively
+ * a passthrough. We use it anyway per the production-code rule in `packages/core/AGENTS.md`
+ * § Encryption — the wrapper is mandatory regardless of current encrypted-field count so
+ * future GDPR additions don't need a route-level migration. Scope hints are required so the
+ * decryption helper can resolve the tenant DEK if any encrypted field is added later.
+ */
 export async function loadCustomerSettings(
   em: EntityManager,
   params: { tenantId: string; organizationId: string }
 ): Promise<CustomerSettings | null> {
-  return em.findOne(CustomerSettings, {
-    tenantId: params.tenantId,
-    organizationId: params.organizationId,
-  })
+  return findOneWithDecryption(
+    em,
+    CustomerSettings,
+    {
+      tenantId: params.tenantId,
+      organizationId: params.organizationId,
+    },
+    undefined,
+    { tenantId: params.tenantId, organizationId: params.organizationId },
+  )
 }
 
 const saveCustomerSettingsCommand: CommandHandler<
@@ -53,3 +73,42 @@ const saveCustomerSettingsCommand: CommandHandler<
 }
 
 registerCommand(saveCustomerSettingsCommand)
+
+const saveStuckThresholdCommand: CommandHandler<
+  CustomerStuckThresholdUpsertInput,
+  { settingsId: string; stuckThresholdDays: number }
+> = {
+  id: 'customers.settings.save_stuck_threshold',
+  async execute(rawInput, ctx) {
+    const input = customerStuckThresholdUpsertSchema.parse(rawInput)
+    ensureTenantScope(ctx, input.tenantId)
+    ensureOrganizationScope(ctx, input.organizationId)
+
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    let settings = await loadCustomerSettings(em, {
+      tenantId: input.tenantId,
+      organizationId: input.organizationId,
+    })
+
+    if (!settings) {
+      settings = em.create(CustomerSettings, {
+        tenantId: input.tenantId,
+        organizationId: input.organizationId,
+        stuckThresholdDays: input.stuckThresholdDays,
+      })
+      em.persist(settings)
+    } else if (settings.stuckThresholdDays !== input.stuckThresholdDays) {
+      settings.stuckThresholdDays = input.stuckThresholdDays
+      settings.updatedAt = new Date()
+    }
+
+    await em.flush()
+
+    return {
+      settingsId: settings.id,
+      stuckThresholdDays: settings.stuckThresholdDays,
+    }
+  },
+}
+
+registerCommand(saveStuckThresholdCommand)

package/src/modules/customers/data/enrichers.ts

@@ -1,3 +1,210 @@
-import type { ResponseEnricher } from '@open-mercato/shared/lib/crud/response-enricher'
+import type { ResponseEnricher, EnricherContext } from '@open-mercato/shared/lib/crud/response-enricher'
+import type { CustomerKysely } from '../lib/kysely'
+import { resolveKyselyClient } from '../lib/kysely'
+import { fetchStuckThresholdDays } from '../lib/stuckDeals'
 
-export const enrichers: ResponseEnricher[] = []
+type DealRecord = Record<string, unknown> & {
+  id: string
+  status?: string | null
+  expected_close_at?: string | null
+  created_at?: string | null
+}
+
+type PipelineState = {
+  openActivitiesCount: number
+  daysInCurrentStage: number
+  isStuck: boolean
+  isOverdue: boolean
+}
+
+const ENRICHER_TIMEOUT_MS = 2000
+const DAY_MS = 24 * 60 * 60 * 1000
+// Mirror the canonical statuses defined in validators.ts (`interactionStatusValues`). The
+// canonical spelling is `canceled` (US, single L), not `cancelled` (UK). Misspelling this
+// here let canceled interactions slip into the open-activities count badge on the card.
+// We accept `completed` defensively too, even though `done` is the canonical "completed"
+// value in the validator, in case any legacy rows exist with the longer spelling.
+const TERMINAL_INTERACTION_STATUSES = ['done', 'canceled', 'completed'] as const
+
+function parseDate(value: unknown): Date | null {
+  if (!value) return null
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value
+  if (typeof value === 'string') {
+    const date = new Date(value)
+    return Number.isNaN(date.getTime()) ? null : date
+  }
+  return null
+}
+
+function diffDays(from: Date, to: Date): number {
+  return Math.floor((to.getTime() - from.getTime()) / DAY_MS)
+}
+
+async function fetchOpenInteractionCounts(
+  db: CustomerKysely,
+  dealIds: Set<string>,
+  organizationId: string,
+  tenantId: string,
+): Promise<Map<string, number>> {
+  const map = new Map<string, number>()
+  if (dealIds.size === 0) return map
+  const rows = await db
+    .selectFrom('customer_interactions')
+    .select(['deal_id'])
+    .select((eb) => eb.fn.countAll().as('count'))
+    .where('deal_id', 'in', [...dealIds])
+    .where('organization_id', '=', organizationId)
+    .where('tenant_id', '=', tenantId)
+    .where('deleted_at', 'is', null)
+    .where('status', 'not in', [...TERMINAL_INTERACTION_STATUSES])
+    .groupBy('deal_id')
+    .execute()
+  for (const row of rows) {
+    if (row.deal_id == null) continue
+    const count = typeof row.count === 'number' ? row.count : Number(row.count)
+    if (Number.isFinite(count)) map.set(row.deal_id, count)
+  }
+  return map
+}
+
+async function fetchLatestStageTransitions(
+  db: CustomerKysely,
+  dealIds: Set<string>,
+  organizationId: string,
+  tenantId: string,
+): Promise<Map<string, Date>> {
+  const map = new Map<string, Date>()
+  if (dealIds.size === 0) return map
+  const rows = await db
+    .selectFrom('customer_deal_stage_transitions')
+    .select(['deal_id'])
+    .select((eb) => eb.fn.max('transitioned_at').as('last_transitioned_at'))
+    .where('deal_id', 'in', [...dealIds])
+    .where('organization_id', '=', organizationId)
+    .where('tenant_id', '=', tenantId)
+    .where('deleted_at', 'is', null)
+    .groupBy('deal_id')
+    .execute()
+  for (const row of rows) {
+    const parsed = parseDate(row.last_transitioned_at)
+    if (parsed) map.set(row.deal_id, parsed)
+  }
+  return map
+}
+
+export function buildPipelineState(
+  record: DealRecord,
+  openInteractionCounts: Map<string, number>,
+  latestTransitions: Map<string, Date>,
+  threshold: number,
+  now: Date,
+  today: Date,
+): PipelineState {
+  const openActivitiesCount = openInteractionCounts.get(record.id) ?? 0
+  const transitionAt =
+    latestTransitions.get(record.id) ?? parseDate(record.created_at) ?? now
+  const daysInCurrentStage = Math.max(0, diffDays(transitionAt, now))
+  const expectedClose = parseDate(record.expected_close_at)
+  const status = typeof record.status === 'string' ? record.status : null
+  const isOverdue = status === 'open' && !!expectedClose && expectedClose < today
+  const isStuck = daysInCurrentStage > threshold
+  return { openActivitiesCount, daysInCurrentStage, isStuck, isOverdue }
+}
+
+const dealPipelineEnricher: ResponseEnricher<DealRecord> = {
+  id: 'customers.deal-pipeline-state',
+  targetEntity: 'customers.deal',
+  // No `features` gate: the deals list route already enforces `customers.deals.view`
+  // at the route-metadata level (see api/deals/route.ts). Declaring `features` here
+  // would silently disable the enricher in environments where `rbacService` resolves
+  // to undefined or `getGrantedFeatures` throws — `hasRequiredFeatures` treats a
+  // missing `userFeatures` as "no access", which made `_pipeline` disappear from
+  // CI responses (TC-CRM-066) while keeping the local kanban working.
+  priority: 10,
+  timeout: ENRICHER_TIMEOUT_MS,
+  critical: false,
+  fallback: {
+    _pipeline: {
+      openActivitiesCount: 0,
+      daysInCurrentStage: 0,
+      isStuck: false,
+      isOverdue: false,
+    },
+  },
+
+  async enrichOne(record, context) {
+    const enriched = await this.enrichMany!([record], context)
+    return enriched[0]
+  },
+
+  async enrichMany(records, context: EnricherContext) {
+    if (records.length === 0) return records
+
+    const now = new Date()
+    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate())
+
+    // `buildPipelineState` is pure on top of (record + maps + threshold). The record alone
+    // is enough to compute `isOverdue` (status + expected_close_at) and a conservative
+    // `daysInCurrentStage` (created_at fallback). When Kysely isn't available on this
+    // EntityManager — test stubs, unusual driver wrappers, or a transient DB issue —
+    // we still ship the correct overdue flag and a zeroed activities count rather than
+    // silently dropping `_pipeline`, which previously made the kanban think every deal
+    // had no stuck/overdue state.
+    const emptyCounts: Map<string, number> = new Map()
+    const emptyTransitions: Map<string, Date> = new Map()
+    const FALLBACK_THRESHOLD = 14
+
+    const db = resolveKyselyClient(context.em)
+    if (!db) {
+      return records.map((record) => ({
+        ...record,
+        _pipeline: buildPipelineState(
+          record,
+          emptyCounts,
+          emptyTransitions,
+          FALLBACK_THRESHOLD,
+          now,
+          today,
+        ),
+      }))
+    }
+
+    const dealIds = new Set<string>()
+    for (const record of records) {
+      if (typeof record.id === 'string') dealIds.add(record.id)
+    }
+    if (dealIds.size === 0) {
+      return records.map((record) => ({
+        ...record,
+        _pipeline: buildPipelineState(
+          record,
+          emptyCounts,
+          emptyTransitions,
+          FALLBACK_THRESHOLD,
+          now,
+          today,
+        ),
+      }))
+    }
+
+    const [openInteractionCounts, latestTransitions, threshold] = await Promise.all([
+      fetchOpenInteractionCounts(db, dealIds, context.organizationId, context.tenantId),
+      fetchLatestStageTransitions(db, dealIds, context.organizationId, context.tenantId),
+      fetchStuckThresholdDays(db, context.organizationId, context.tenantId),
+    ])
+
+    return records.map((record) => ({
+      ...record,
+      _pipeline: buildPipelineState(
+        record,
+        openInteractionCounts,
+        latestTransitions,
+        threshold,
+        now,
+        today,
+      ),
+    }))
+  },
+}
+
+export const enrichers: ResponseEnricher[] = [dealPipelineEnricher]

package/src/modules/customers/data/entities.ts

@@ -750,7 +750,7 @@ export class CustomerAddress {
 @Entity({ tableName: 'customer_settings' })
 @Unique({ name: 'customer_settings_scope_unique', properties: ['organizationId', 'tenantId'] })
 export class CustomerSettings {
-  [OptionalProps]?: 'createdAt' | 'updatedAt'
+  [OptionalProps]?: 'createdAt' | 'updatedAt' | 'addressFormat' | 'stuckThresholdDays'
 
   @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
   id!: string
@@ -764,6 +764,9 @@ export class CustomerSettings {
   @Property({ name: 'address_format', type: 'text', default: 'line_first' })
   addressFormat: CustomerAddressFormat = 'line_first'
 
+  @Property({ name: 'stuck_threshold_days', type: 'int', default: 14 })
+  stuckThresholdDays: number = 14
+
   @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
   createdAt: Date = new Date()
 

package/src/modules/customers/data/validators.ts

@@ -126,7 +126,10 @@ export const dealCreateSchema = scopedSchema.extend({
   valueCurrency: z.string().min(3).max(3).optional(),
   probability: z.number().min(0).max(100).optional(),
   expectedCloseAt: z.coerce.date().optional(),
-  ownerUserId: uuid().optional(),
+  // Nullable: the bulk owner-update worker passes `null` to clear ownership.
+  // Without `.nullable()`, dealUpdateSchema.parse({ ownerUserId: null }) throws
+  // ZodError "expected string, received null" inside the queue worker (TC-CRM-069).
+  ownerUserId: uuid().optional().nullable(),
   source: z.string().max(150).optional(),
   closureOutcome: z.enum(['won', 'lost']).optional(),
   lossReasonId: uuid().optional(),
@@ -141,6 +144,24 @@ export const dealUpdateSchema = z
   })
   .merge(dealCreateSchema.partial())
 
+// Bulk update schemas — used by `api/deals/bulk-update-{owner,stage}/route.ts`. Kept here
+// so all deal-write contracts live next to `dealCreateSchema` / `dealUpdateSchema`.
+export const dealsBulkUpdateOwnerSchema = z.object({
+  ids: z.array(uuid()).min(1).max(10000),
+  ownerUserId: uuid().nullable(),
+})
+
+export const dealsBulkUpdateStageSchema = z.object({
+  ids: z.array(uuid()).min(1).max(10000),
+  pipelineStageId: uuid(),
+})
+
+export const dealsBulkUpdateResponseSchema = z.object({
+  ok: z.boolean(),
+  progressJobId: uuid().nullable(),
+  message: z.string(),
+})
+
 export const activityCreateSchema = scopedSchema.extend({
   entityId: uuid(),
   activityType: z.string().min(1).max(100),
@@ -252,10 +273,18 @@ const dictionaryKindEnum = z.string().trim().refine(
 
 const dictionaryValueSchema = z.string().trim().min(1).max(150)
 const dictionaryLabelSchema = z.string().trim().max(150)
+// Pipeline-stage rows migrated to semantic tone identifiers in
+// Migration20260519120000_pipeline_stage_color_tones; AddStageDialog now writes those
+// directly. Other dictionary kinds still store hex. Accept either format so round-tripping
+// a migrated pipeline-stage entry through the dictionary edit UI doesn't fail validation.
+const DICTIONARY_COLOR_TONES = ['success', 'warning', 'info', 'error', 'neutral', 'brand', 'pink'] as const
 const dictionaryColorSchema = z
   .string()
   .trim()
-  .regex(/^#([0-9a-fA-F]{6})$/, 'Color must be a valid six-digit hex code like #3366ff')
+  .regex(
+    new RegExp(`^(#[0-9a-fA-F]{6}|${DICTIONARY_COLOR_TONES.join('|')})$`),
+    'Color must be a six-digit hex code (e.g. #3366ff) or a semantic tone identifier',
+  )
 const dictionaryIconSchema = z.string().trim().max(48)
 
 export const customerDictionaryEntryCreateSchema = scopedSchema.extend({
@@ -497,6 +526,10 @@ export const customerSettingsUpsertSchema = scopedSchema.extend({
   addressFormat: customerAddressFormatSchema,
 })
 
+export const customerStuckThresholdUpsertSchema = scopedSchema.extend({
+  stuckThresholdDays: z.number().int().min(1).max(365),
+})
+
 export type PersonCreateInput = z.infer<typeof personCreateSchema>
 export type PersonUpdateInput = z.infer<typeof personUpdateSchema>
 export type CompanyCreateInput = z.infer<typeof companyCreateSchema>
@@ -515,6 +548,7 @@ export type TagAssignmentInput = z.infer<typeof tagAssignmentSchema>
 export type TodoLinkCreateInput = z.infer<typeof todoLinkCreateSchema>
 export type TodoLinkWithTodoCreateInput = z.infer<typeof todoLinkWithTodoCreateSchema>
 export type CustomerSettingsUpsertInput = z.infer<typeof customerSettingsUpsertSchema>
+export type CustomerStuckThresholdUpsertInput = z.infer<typeof customerStuckThresholdUpsertSchema>
 export type CustomerAddressFormatInput = z.infer<typeof customerAddressFormatSchema>
 export type InteractionCompleteInput = z.infer<typeof interactionCompleteSchema>
 export type InteractionCancelInput = z.infer<typeof interactionCancelSchema>