@open-mercato/core 0.7.1-develop.7122.1.421cefe668 → 0.7.1-develop.7130.1.fef2396fd8

package/src/modules/customers/api/deals/aggregate/route.ts

@@ -1,7 +1,9 @@
+import { createHash } from 'node:crypto'
 import { NextResponse } from 'next/server'
 import { z } from 'zod'
 import type { EntityManager as CoreEntityManager } from '@mikro-orm/core'
 import type { EntityManager as PgEntityManager } from '@mikro-orm/postgresql'
+import { runWithCacheTenant } from '@open-mercato/cache'
 import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
@@ -11,6 +13,12 @@ import type { ExchangeRateService } from '@open-mercato/core/modules/currencies/
 import { parseBooleanFromUnknown } from '@open-mercato/shared/lib/boolean'
 import { escapeLikePattern } from '@open-mercato/shared/lib/db/escapeLikePattern'
 import type { CrudCtx } from '@open-mercato/shared/lib/crud/factory'
+import {
+  buildCollectionTags,
+  debugCrudCache,
+  isCrudCacheEnabled,
+  resolveCrudCache,
+} from '@open-mercato/shared/lib/crud/cache'
 import { readQueryParamList } from '@open-mercato/shared/lib/crud/query-params'
 import { isTenantDataEncryptionEnabled } from '@open-mercato/shared/lib/encryption/toggles'
 import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
@@ -21,6 +29,8 @@ import { E } from '#generated/entities.ids.generated'
 import { createLogger } from '@open-mercato/shared/lib/logger'
 
 const logger = createLogger('customers')
+const DEALS_AGGREGATE_CACHE_RESOURCE = 'customers.deal'
+const DEALS_AGGREGATE_CACHE_TTL_MS = 30_000
 
 export const metadata = {
   GET: { requireAuth: true, requireFeatures: ['customers.deals.view'] },
@@ -45,6 +55,40 @@ const querySchema = z.object({
   expectedCloseAtTo: z.string().optional(),
 })
 
+type AggregateQuery = z.infer<typeof querySchema>
+
+function normalizeStringSet(values: string[] | undefined): string[] {
+  return Array.from(new Set((values ?? []).map((value) => value.trim())))
+    .sort((left, right) => (left < right ? -1 : left > right ? 1 : 0))
+}
+
+function buildDealsAggregateCacheKey(params: {
+  tenantId: string
+  currencyScopeOrganizationId: string | null
+  organizationIds: string[]
+  query: AggregateQuery
+}): string {
+  const signature = {
+    tenantId: params.tenantId,
+    currencyScopeOrganizationId: params.currencyScopeOrganizationId,
+    organizationIds: normalizeStringSet(params.organizationIds),
+    pipelineId: params.query.pipelineId ?? null,
+    status: normalizeStringSet(params.query.status),
+    ownerUserId: normalizeStringSet(params.query.ownerUserId),
+    personId: normalizeStringSet(params.query.personId),
+    companyId: normalizeStringSet(params.query.companyId),
+    expectedCloseAtFrom: params.query.expectedCloseAtFrom ?? null,
+    expectedCloseAtTo: params.query.expectedCloseAtTo ?? null,
+    isOverdue: params.query.isOverdue === true,
+  }
+  const digest = createHash('sha256').update(JSON.stringify(signature)).digest('hex')
+  return `customers:deal:aggregate:v1:${digest}`
+}
+
+function isDealsAggregateCacheEligible(searchParams: URLSearchParams): boolean {
+  return !searchParams.has('search') && !searchParams.has('isStuck')
+}
+
 type StageBreakdownByCurrency = {
   currency: string
   total: number
@@ -175,6 +219,42 @@ export async function GET(req: Request) {
     return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
   }
   const orgFilterIds = await resolveDealsOrganizationIds({ em, scope, auth, tenantId: effectiveTenantId })
+  const aggregateCache = isDealsAggregateCacheEligible(params) && isCrudCacheEnabled()
+    ? resolveCrudCache(container)
+    : null
+  const aggregateCacheKey = aggregateCache
+    ? buildDealsAggregateCacheKey({
+        tenantId: effectiveTenantId,
+        currencyScopeOrganizationId: orgFilterIds[0] ?? null,
+        organizationIds: orgFilterIds,
+        query: parsed.data,
+      })
+    : null
+
+  if (aggregateCache && aggregateCacheKey) {
+    try {
+      const cached = await runWithCacheTenant(
+        effectiveTenantId,
+        () => aggregateCache.get(aggregateCacheKey),
+      )
+      const cachedResponse = aggregateResponseSchema.safeParse(cached)
+      if (cachedResponse.success) {
+        return NextResponse.json(cachedResponse.data)
+      }
+      if (cached !== null && cached !== undefined) {
+        debugCrudCache('get-invalid', {
+          resource: DEALS_AGGREGATE_CACHE_RESOURCE,
+          key: aggregateCacheKey,
+        })
+      }
+    } catch (err) {
+      debugCrudCache('get', {
+        resource: DEALS_AGGREGATE_CACHE_RESOURCE,
+        key: aggregateCacheKey,
+        error: err instanceof Error ? err.message : String(err),
+      })
+    }
+  }
 
   // Raw SQL is used here intentionally — the route only projects non-encrypted columns
   // (`pipeline_stage_id`, `value_amount`, `value_currency`, `status`, plus filters). It
@@ -443,5 +523,27 @@ export async function GET(req: Request) {
     perStage: Array.from(stageMap.values()),
   }
 
+  if (aggregateCache && aggregateCacheKey) {
+    try {
+      await runWithCacheTenant(
+        effectiveTenantId,
+        () => aggregateCache.set(aggregateCacheKey, response, {
+          ttl: DEALS_AGGREGATE_CACHE_TTL_MS,
+          tags: buildCollectionTags(
+            DEALS_AGGREGATE_CACHE_RESOURCE,
+            effectiveTenantId,
+            normalizeStringSet(orgFilterIds),
+          ),
+        }),
+      )
+    } catch (err) {
+      debugCrudCache('store', {
+        resource: DEALS_AGGREGATE_CACHE_RESOURCE,
+        key: aggregateCacheKey,
+        error: err instanceof Error ? err.message : String(err),
+      })
+    }
+  }
+
   return NextResponse.json(response)
 }

package/src/modules/customers/backend/customers/deals/[id]/hooks/types.ts

@@ -6,29 +6,6 @@ export type DealAssociation = {
   isPrimary?: boolean
 }
 
-export type PersonAssociationApiRecord = {
-  id?: string
-  displayName?: string | null
-  display_name?: string | null
-  primaryEmail?: string | null
-  primary_email?: string | null
-  primaryPhone?: string | null
-  primary_phone?: string | null
-  personProfile?: { jobTitle?: string | null } | null
-  person_profile?: { jobTitle?: string | null } | null
-}
-
-export type CompanyAssociationApiRecord = {
-  id?: string
-  displayName?: string | null
-  display_name?: string | null
-  domain?: string | null
-  websiteUrl?: string | null
-  website_url?: string | null
-  companyProfile?: { domain?: string | null; websiteUrl?: string | null } | null
-  company_profile?: { domain?: string | null; websiteUrl?: string | null } | null
-}
-
 export type PipelineStageInfo = {
   id: string
   label: string

package/src/modules/customers/backend/customers/deals/[id]/hooks/useDealAssociations.ts

@@ -6,81 +6,11 @@ import { readApiResultOrThrow, withScopedApiRequestHeaders } from '@open-mercato
 import { buildOptimisticLockHeader } from '@open-mercato/ui/backend/utils/optimisticLock'
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import type {
-  CompanyAssociationApiRecord,
   DealAssociation,
   DealDetailPayload,
   GuardedMutationRunner,
-  PersonAssociationApiRecord,
 } from './types'
 
-export function normalizePersonAssociationRecord(
-  record: PersonAssociationApiRecord,
-  fallbackId: string,
-): DealAssociation {
-  const displayName =
-    typeof record.displayName === 'string' && record.displayName.trim().length
-      ? record.displayName.trim()
-      : typeof record.display_name === 'string' && record.display_name.trim().length
-        ? record.display_name.trim()
-        : null
-  const email =
-    typeof record.primaryEmail === 'string' && record.primaryEmail.trim().length
-      ? record.primaryEmail.trim()
-      : typeof record.primary_email === 'string' && record.primary_email.trim().length
-        ? record.primary_email.trim()
-        : null
-  const phone =
-    typeof record.primaryPhone === 'string' && record.primaryPhone.trim().length
-      ? record.primaryPhone.trim()
-      : typeof record.primary_phone === 'string' && record.primary_phone.trim().length
-        ? record.primary_phone.trim()
-        : null
-  const profile = record.personProfile ?? record.person_profile ?? null
-  const jobTitle =
-    profile && typeof profile.jobTitle === 'string' && profile.jobTitle.trim().length
-      ? profile.jobTitle.trim()
-      : null
-  return {
-    id: typeof record.id === 'string' ? record.id : fallbackId,
-    label: displayName ?? email ?? phone ?? fallbackId,
-    subtitle: jobTitle ?? email ?? phone ?? null,
-    kind: 'person',
-  }
-}
-
-export function normalizeCompanyAssociationRecord(
-  record: CompanyAssociationApiRecord,
-  fallbackId: string,
-): DealAssociation {
-  const displayName =
-    typeof record.displayName === 'string' && record.displayName.trim().length
-      ? record.displayName.trim()
-      : typeof record.display_name === 'string' && record.display_name.trim().length
-        ? record.display_name.trim()
-        : null
-  const profile = record.companyProfile ?? record.company_profile ?? null
-  const domain =
-    typeof record.domain === 'string' && record.domain.trim().length
-      ? record.domain.trim()
-      : profile && typeof profile.domain === 'string' && profile.domain.trim().length
-        ? profile.domain.trim()
-        : null
-  const website =
-    typeof record.websiteUrl === 'string' && record.websiteUrl.trim().length
-      ? record.websiteUrl.trim()
-      : typeof record.website_url === 'string' && record.website_url.trim().length
-        ? record.website_url.trim()
-        : profile && typeof profile.websiteUrl === 'string' && profile.websiteUrl.trim().length
-          ? profile.websiteUrl.trim()
-          : null
-  return {
-    id: typeof record.id === 'string' ? record.id : fallbackId,
-    label: displayName ?? domain ?? website ?? fallbackId,
-    subtitle: domain ?? website ?? null,
-    kind: 'company',
-  }
-}
-
 function sameIdList(left: string[], right: string[]): boolean {
   if (left.length !== right.length) return false
   return left.every((value, index) => value === right[index])
@@ -97,8 +27,12 @@ type UseDealAssociationsOptions = {
   data: DealDetailPayload | null
   setData: React.Dispatch<React.SetStateAction<DealDetailPayload | null>>
   runMutationWithContext: GuardedMutationRunner
-  /** Re-fetch the deal detail; wired into the conflict bar's refresh action on a 409. */
-  onRefresh?: (() => void) | null
+  /**
+   * Re-fetch the deal detail. Required, not optional: this hook no longer patches the list
+   * itself on success, so a caller without it would show a stale list *and* keep a superseded
+   * lock token that 409s on the next save. It also backs the conflict bar's refresh on a 409.
+   */
+  onRefresh: () => void | Promise<void>
 }
 
 type UseDealAssociationsResult = {
@@ -130,80 +64,6 @@ export function useDealAssociations({
     setCompaniesEditorIds(data?.linkedCompanyIds ?? [])
   }, [data?.linkedCompanyIds, data?.linkedPersonIds])
 
-  const loadPeopleAssociations = React.useCallback(async (ids: string[]): Promise<DealAssociation[]> => {
-    const uniqueIds = Array.from(new Set(ids.map((value) => value.trim()).filter(Boolean)))
-    if (!uniqueIds.length) return []
-    try {
-      const params = new URLSearchParams({
-        ids: uniqueIds.join(','),
-        pageSize: String(Math.max(uniqueIds.length, 1)),
-      })
-      const payload = await readApiResultOrThrow<{ items?: PersonAssociationApiRecord[] }>(
-        `/api/customers/people?${params.toString()}`,
-      )
-      const items = Array.isArray(payload.items) ? payload.items : []
-      const byId = new Map<string, PersonAssociationApiRecord>()
-      items.forEach((record) => {
-        if (record && typeof record.id === 'string') byId.set(record.id, record)
-      })
-      return uniqueIds.map((personId) => {
-        const record = byId.get(personId)
-        return record
-          ? normalizePersonAssociationRecord(record, personId)
-          : {
-              id: personId,
-              label: personId,
-              subtitle: null,
-              kind: 'person' as const,
-            }
-      })
-    } catch {
-      return uniqueIds.map((personId) => ({
-        id: personId,
-        label: personId,
-        subtitle: null,
-        kind: 'person' as const,
-      }))
-    }
-  }, [])
-
-  const loadCompanyAssociations = React.useCallback(async (ids: string[]): Promise<DealAssociation[]> => {
-    const uniqueIds = Array.from(new Set(ids.map((value) => value.trim()).filter(Boolean)))
-    if (!uniqueIds.length) return []
-    try {
-      const params = new URLSearchParams({
-        ids: uniqueIds.join(','),
-        pageSize: String(Math.max(uniqueIds.length, 1)),
-      })
-      const payload = await readApiResultOrThrow<{ items?: CompanyAssociationApiRecord[] }>(
-        `/api/customers/companies?${params.toString()}`,
-      )
-      const items = Array.isArray(payload.items) ? payload.items : []
-      const byId = new Map<string, CompanyAssociationApiRecord>()
-      items.forEach((record) => {
-        if (record && typeof record.id === 'string') byId.set(record.id, record)
-      })
-      return uniqueIds.map((companyId) => {
-        const record = byId.get(companyId)
-        return record
-          ? normalizeCompanyAssociationRecord(record, companyId)
-          : {
-              id: companyId,
-              label: companyId,
-              subtitle: null,
-              kind: 'company' as const,
-            }
-      })
-    } catch {
-      return uniqueIds.map((companyId) => ({
-        id: companyId,
-        label: companyId,
-        subtitle: null,
-        kind: 'company' as const,
-      }))
-    }
-  }, [])
-
   const loadLinkedPeoplePage = React.useCallback(
     async (page: number, query: string): Promise<LinkedPageResult> => {
       if (!currentDealId) {
@@ -274,17 +134,7 @@ export function useDealAssociations({
           ),
           { id: currentDealId, personIds: nextIds, operation: 'updateDealPeople' },
         )
-        const nextPeople = await loadPeopleAssociations(nextIds.slice(0, 3))
-        setData((prev) =>
-          prev
-            ? {
-                ...prev,
-                people: nextPeople,
-                linkedPersonIds: nextIds,
-                counts: { ...prev.counts, people: nextIds.length },
-              }
-            : prev,
-        )
+        await onRefresh()
       } catch (error) {
         setPeopleEditorIds(previousIds)
         setData((prev) =>
@@ -299,14 +149,14 @@ export function useDealAssociations({
         )
         // runMutationWithContext already surfaces the conflict bar on a 409; only
         // fall back to the generic flash when this is not a record conflict.
-        if (!surfaceRecordConflict(error, t, { onRefresh: onRefresh ?? null })) {
+        if (!surfaceRecordConflict(error, t, { onRefresh })) {
           flash(t('customers.deals.detail.peopleUpdateError', 'Failed to update linked people.'), 'error')
         }
       } finally {
         setPeopleSaving(false)
       }
     },
-    [currentDealId, data?.deal.updatedAt, data?.people, loadPeopleAssociations, onRefresh, peopleEditorIds, runMutationWithContext, setData, t],
+    [currentDealId, data?.deal.updatedAt, data?.people, onRefresh, peopleEditorIds, runMutationWithContext, setData, t],
   )
 
   const handleCompaniesAssociationsChange = React.useCallback(
@@ -325,17 +175,7 @@ export function useDealAssociations({
           ),
           { id: currentDealId, companyIds: nextIds, operation: 'updateDealCompanies' },
         )
-        const nextCompanies = await loadCompanyAssociations(nextIds.slice(0, 3))
-        setData((prev) =>
-          prev
-            ? {
-                ...prev,
-                companies: nextCompanies,
-                linkedCompanyIds: nextIds,
-                counts: { ...prev.counts, companies: nextIds.length },
-              }
-            : prev,
-        )
+        await onRefresh()
       } catch (error) {
         setCompaniesEditorIds(previousIds)
         setData((prev) =>
@@ -350,7 +190,7 @@ export function useDealAssociations({
         )
         // runMutationWithContext already surfaces the conflict bar on a 409; only
         // fall back to the generic flash when this is not a record conflict.
-        if (!surfaceRecordConflict(error, t, { onRefresh: onRefresh ?? null })) {
+        if (!surfaceRecordConflict(error, t, { onRefresh })) {
           flash(t('customers.deals.detail.companiesUpdateError', 'Failed to update linked companies.'), 'error')
         }
       } finally {
@@ -362,7 +202,6 @@ export function useDealAssociations({
       currentDealId,
       data?.companies,
       data?.deal.updatedAt,
-      loadCompanyAssociations,
       onRefresh,
       runMutationWithContext,
       setData,

package/src/modules/customers/backend/customers/deals/[id]/page.tsx

@@ -198,7 +198,7 @@ export default function DealDetailPage({ params }: { params?: { id?: string } })
     data,
     setData,
     runMutationWithContext,
-    onRefresh: () => { void loadData() },
+    onRefresh: () => loadData(),
   })
 
   const { isStageSaving, handleStageChange } = useDealPipeline({

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

@@ -383,12 +383,49 @@ function toNumericString(value: number | null | undefined): string | null {
   return value.toString()
 }
 
+function sameLinkIdSet(next: Set<string>, current: Set<string>): boolean {
+  if (next.size !== current.size) return false
+  for (const id of next) {
+    if (!current.has(id)) return false
+  }
+  return true
+}
+
+/**
+ * The deal's optimistic-lock token is `customer_deals.updated_at`, and `CustomerDeal.updatedAt`
+ * is declared `onUpdate`-only — it advances only when the deal entity itself enters the change
+ * set. A `{ id, personIds }` or `{ id, companyIds }` payload mutates link rows exclusively, so
+ * without this explicit touch the token never moves: two clients editing the same deal's links
+ * from the same base version both pass the version check and the later stale whole-set payload
+ * silently reinstates what the earlier one removed.
+ *
+ * Assigning the property is what dirties the entity; the `onUpdate` hook then supplies the
+ * committed value, so the two do not fight. Same pattern as the profile-only branch in
+ * `people.ts`, which touches its parent for exactly this reason.
+ *
+ * Callers MUST only invoke this when the links actually changed — stamping on a no-op write
+ * would invalidate every other session's token on an idle save.
+ *
+ * ORDERING: this MUST be the last thing a sync helper does. MikroORM v7 discards a pending
+ * scalar change on a managed entity when a query runs on the same EntityManager before the
+ * flush (SPEC-018) — the same footgun the CRITICAL comment in `updateDealCommand` guards
+ * against, and these helpers are exactly the queries it names. Touching before
+ * `requireCustomerEntity` runs would silently drop the UPDATE and leave the token frozen.
+ */
+function touchDealLockToken(deal: CustomerDeal): void {
+  deal.updatedAt = new Date()
+}
+
 async function syncDealPeople(
   em: EntityManager,
   deal: CustomerDeal,
   personIds: string[] | undefined | null,
-  primaryPersonEntityId?: string | null
+  primaryPersonEntityId?: string | null,
+  options?: { stampLockToken?: boolean }
 ): Promise<void> {
+  // A freshly created deal has no other session holding a token to invalidate, and stamping
+  // there would only make `updated_at` overtake `created_at` on every new deal with links.
+  const stampLockToken = options?.stampLockToken !== false
   if (personIds === undefined) {
     if (primaryPersonEntityId === undefined) return
     const links = await em.find(CustomerDealPersonLink, { deal })
@@ -401,6 +438,18 @@ async function syncDealPeople(
         ),
       })
     }
+    const currentPrimaryId = links.find((link) => link.isPrimary)?.person?.id ?? null
+    // Nothing changed — same invariant the whole-set branch below enforces. Without this the
+    // clear loop and its flush would rewrite every link row just to put the flag back on the
+    // row it was already on, and would briefly leave the deal with no primary at all inside
+    // the transaction. Only one row can carry the flag (partial unique index on
+    // `deal_id where is_primary`), so there is no second stale flag left to clean up here.
+    if (currentPrimaryId === primaryPersonEntityId) return
+    // Safe here: only assignments and the explicit flush below follow — no query runs
+    // between this touch and the flush that persists it.
+    if (stampLockToken) {
+      touchDealLockToken(deal)
+    }
     for (const link of links) {
       link.isPrimary = false
     }
@@ -421,13 +470,30 @@ async function syncDealPeople(
       ),
     })
   }
+  // Read the current links once: this both resolves the inherited primary (as the previous
+  // `findOne(..., { isPrimary: true })` did) and lets us tell a real change from a no-op save,
+  // which the lock stamp below depends on.
+  const existingLinks = await em.find(CustomerDealPersonLink, { deal })
+  const currentPersonIds = new Set(existingLinks.map((link) => link.person.id))
+  const currentPrimaryId = existingLinks.find((link) => link.isPrimary)?.person?.id ?? null
+
   let effectivePrimaryId = primaryPersonEntityId
   if (effectivePrimaryId === undefined) {
-    const existingPrimary = await em.findOne(CustomerDealPersonLink, { deal, isPrimary: true })
-    effectivePrimaryId = existingPrimary?.person?.id ?? null
+    effectivePrimaryId = currentPrimaryId
   }
+  const linksChanged =
+    !sameLinkIdSet(new Set(unique), currentPersonIds) || effectivePrimaryId !== currentPrimaryId
+  // Nothing to do. Returning here also stops a no-op save from deleting and recreating every
+  // row, which would otherwise discard `participant_role`, `created_at` and the link ids while
+  // this function reports the write as a no-op to every other session.
+  //
+  // NOTE: this only covers the pure no-op. A genuine change below still deletes and recreates
+  // every row, so surviving participants do lose those columns — pre-existing behaviour that
+  // the set-diff in PR 3 of the linked-people parity spec removes. It is out of scope here
+  // because the linked date it corrupts is not rendered until that PR.
+  if (!linksChanged) return
+
   await em.nativeDelete(CustomerDealPersonLink, { deal })
-  if (!unique.length) return
   for (const personId of unique) {
     const person = await requireCustomerEntity(em, personId, { tenantId: deal.tenantId, organizationId: deal.organizationId }, 'person', 'Person not found')
     ensureSameScope(person, deal.organizationId, deal.tenantId)
@@ -438,17 +504,24 @@ async function syncDealPeople(
     })
     em.persist(link)
   }
+  // Last statement on purpose — see the ORDERING note on `touchDealLockToken`.
+  if (stampLockToken) touchDealLockToken(deal)
 }
 
 async function syncDealCompanies(
   em: EntityManager,
   deal: CustomerDeal,
-  companyIds: string[] | undefined | null
+  companyIds: string[] | undefined | null,
+  options?: { stampLockToken?: boolean }
 ): Promise<void> {
   if (companyIds === undefined) return
+  const stampLockToken = options?.stampLockToken !== false
+  const unique = Array.from(new Set(companyIds ?? []))
+  const existingLinks = await em.find(CustomerDealCompanyLink, { deal })
+  const currentCompanyIds = new Set(existingLinks.map((link) => link.company.id))
+  if (sameLinkIdSet(new Set(unique), currentCompanyIds)) return
+
   await em.nativeDelete(CustomerDealCompanyLink, { deal })
-  if (!companyIds || !companyIds.length) return
-  const unique = Array.from(new Set(companyIds))
   for (const companyId of unique) {
     const company = await requireCustomerEntity(em, companyId, { tenantId: deal.tenantId, organizationId: deal.organizationId }, 'company', 'Company not found')
     ensureSameScope(company, deal.organizationId, deal.tenantId)
@@ -458,6 +531,8 @@ async function syncDealCompanies(
     })
     em.persist(link)
   }
+  // Last statement on purpose — see the ORDERING note on `touchDealLockToken`.
+  if (stampLockToken) touchDealLockToken(deal)
 }
 
 const createDealCommand: CommandHandler<DealCreateInput, { dealId: string }> = {
@@ -530,8 +605,8 @@ const createDealCommand: CommandHandler<DealCreateInput, { dealId: string }> = {
           transitionedByUserId: normalizedTransitionAuthorUserId,
         })
       },
-      () => syncDealPeople(em, deal, parsed.personIds ?? [], parsed.primaryPersonEntityId),
-      () => syncDealCompanies(em, deal, parsed.companyIds ?? []),
+      () => syncDealPeople(em, deal, parsed.personIds ?? [], parsed.primaryPersonEntityId, { stampLockToken: false }),
+      () => syncDealCompanies(em, deal, parsed.companyIds ?? [], { stampLockToken: false }),
     ], { transaction: true })
 
     const de = (ctx.container.resolve('dataEngine') as DataEngine)