@open-mercato/core 0.5.1-develop.2663.2c29774b5b → 0.5.1-develop.2681.c559bb2bc3

package/src/modules/customers/lib/customerRoleTypes.ts

@@ -0,0 +1,24 @@
+import type { DictionaryEntryOption } from '@open-mercato/core/modules/dictionaries/lib/clientEntries'
+
+export type CustomerRoleTypeSeed = {
+  value: string
+  label: string
+  color: string | null
+  icon: string | null
+}
+
+export const DEFAULT_CUSTOMER_ROLE_TYPES: CustomerRoleTypeSeed[] = [
+  { value: 'sales_owner', label: 'Sales Owner', color: '#2563eb', icon: 'lucide:briefcase' },
+  { value: 'service_owner', label: 'Service Owner', color: '#16a34a', icon: 'lucide:headphones' },
+  { value: 'account_manager', label: 'Account Manager', color: '#f59e0b', icon: 'lucide:user-check' },
+]
+
+export function createDefaultCustomerRoleTypeOptions(): DictionaryEntryOption[] {
+  return DEFAULT_CUSTOMER_ROLE_TYPES.map((entry) => ({
+    id: `default:${entry.value}`,
+    value: entry.value,
+    label: entry.label,
+    color: entry.color,
+    icon: entry.icon,
+  }))
+}

package/src/modules/customers/lib/dealClosureNotification.ts

@@ -0,0 +1,64 @@
+import { resolveNotificationService } from '../../notifications/lib/notificationService'
+import { buildNotificationFromType } from '../../notifications/lib/notificationBuilder'
+import { notificationTypes } from '../notifications'
+
+export type DealClosurePayload = {
+  id: string
+  tenantId: string | null
+  organizationId: string | null
+  ownerUserId: string | null
+  title: string
+  valueAmount: string | null
+  valueCurrency: string | null
+}
+
+type ResolverContext = {
+  resolve: <T = unknown>(name: string) => T
+  container?: { resolve<T = unknown>(name: string): T }
+}
+
+export type DealClosureNotificationType = 'customers.deal.won' | 'customers.deal.lost'
+
+export async function deliverDealClosureNotification(
+  payload: DealClosurePayload,
+  ctx: ResolverContext,
+  notificationType: DealClosureNotificationType,
+): Promise<void> {
+  if (!payload?.ownerUserId || !payload.tenantId) return
+
+  const typeDef = notificationTypes.find((type) => type.type === notificationType)
+  if (!typeDef) return
+
+  const container = ctx.container ?? { resolve: ctx.resolve }
+  let notificationService: ReturnType<typeof resolveNotificationService> | null
+  try {
+    notificationService = resolveNotificationService(container)
+  } catch (err) {
+    console.warn('[customers.dealClosureNotification] notificationService resolve failed', err)
+    return
+  }
+
+  const valueDisplay = payload.valueAmount && payload.valueCurrency
+    ? `${payload.valueCurrency} ${payload.valueAmount}`
+    : ''
+
+  const notificationInput = buildNotificationFromType(typeDef, {
+    recipientUserId: payload.ownerUserId,
+    bodyVariables: {
+      dealTitle: payload.title,
+      dealValue: valueDisplay,
+    },
+    sourceEntityType: 'customers:customer_deal',
+    sourceEntityId: payload.id,
+    linkHref: `/backend/customers/deals/${payload.id}`,
+  })
+
+  try {
+    await notificationService.create(notificationInput, {
+      tenantId: payload.tenantId,
+      organizationId: payload.organizationId ?? null,
+    })
+  } catch (err) {
+    console.warn('[customers.dealClosureNotification] create failed', notificationType, err)
+  }
+}

package/src/modules/customers/lib/dealStageTransitionTable.ts

@@ -0,0 +1,32 @@
+import { TableNotFoundException } from '@mikro-orm/core'
+
+const DEAL_STAGE_TRANSITIONS_TABLE = 'customer_deal_stage_transitions'
+
+let warnedAboutMissingDealStageTransitionTable = false
+
+export function isMissingDealStageTransitionTable(error: unknown): boolean {
+  if (error instanceof TableNotFoundException) {
+    return true
+  }
+  if (typeof error !== 'object' || error === null) {
+    return false
+  }
+  const candidate = error as { code?: unknown; message?: unknown }
+  const message = typeof candidate.message === 'string' ? candidate.message : null
+
+  if (candidate.code === '42P01') {
+    return !message || message.includes(DEAL_STAGE_TRANSITIONS_TABLE)
+  }
+
+  return !!message
+    && message.includes(DEAL_STAGE_TRANSITIONS_TABLE)
+    && message.includes('does not exist')
+}
+
+export function warnMissingDealStageTransitionTable(source: string): void {
+  if (warnedAboutMissingDealStageTransitionTable) {
+    return
+  }
+  warnedAboutMissingDealStageTransitionTable = true
+  console.warn(`[${source}] missing ${DEAL_STAGE_TRANSITIONS_TABLE} table; returning without stage history. Run yarn db:migrate.`)
+}

package/src/modules/customers/lib/dictionaries.ts

@@ -11,19 +11,35 @@ import {
   renderDictionaryIcon,
 } from '@open-mercato/core/modules/dictionaries/components/dictionaryAppearance'
 
-export type CustomerDictionaryKind =
-  | 'statuses'
-  | 'sources'
-  | 'lifecycle-stages'
-  | 'address-types'
-  | 'activity-types'
-  | 'deal-statuses'
-  | 'pipeline-stages'
-  | 'job-titles'
-  | 'industries'
+export const CUSTOMER_DICTIONARY_KINDS = [
+  'statuses',
+  'sources',
+  'lifecycle-stages',
+  'address-types',
+  'activity-types',
+  'deal-statuses',
+  'pipeline-stages',
+  'job-titles',
+  'industries',
+  'temperature',
+  'renewal-quarters',
+  'person-company-roles',
+] as const
+
+export type CustomerDictionaryKind = typeof CUSTOMER_DICTIONARY_KINDS[number]
 export type CustomerDictionaryDisplayEntry = DictionaryDisplayEntry
 export type CustomerDictionaryMap = DictionaryMap
 
+export function createEmptyCustomerDictionaryMaps(): Record<CustomerDictionaryKind, CustomerDictionaryMap> {
+  return CUSTOMER_DICTIONARY_KINDS.reduce<Record<CustomerDictionaryKind, CustomerDictionaryMap>>(
+    (acc, kind) => {
+      acc[kind] = {}
+      return acc
+    },
+    {} as Record<CustomerDictionaryKind, CustomerDictionaryMap>,
+  )
+}
+
 export {
   ICON_LIBRARY,
   ICON_SUGGESTIONS,

package/src/modules/customers/lib/interactionReadModel.ts

@@ -183,6 +183,16 @@ export async function hydrateCanonicalInteractions({
       appearanceIcon: interaction.appearanceIcon ?? null,
       appearanceColor: interaction.appearanceColor ?? null,
       source: interaction.source ?? null,
+      duration: interaction.durationMinutes ?? null,
+      location: interaction.location ?? null,
+      allDay: interaction.allDay ?? null,
+      recurrenceRule: interaction.recurrenceRule ?? null,
+      recurrenceEnd: interaction.recurrenceEnd ? interaction.recurrenceEnd.toISOString() : null,
+      participants: interaction.participants ?? null,
+      reminderMinutes: interaction.reminderMinutes ?? null,
+      visibility: interaction.visibility ?? null,
+      linkedEntities: interaction.linkedEntities ?? null,
+      guestPermissions: interaction.guestPermissions ?? null,
       organizationId: interaction.organizationId,
       tenantId: interaction.tenantId,
       createdAt: interaction.createdAt.toISOString(),

package/src/modules/customers/lib/personCompanies.ts

@@ -0,0 +1,317 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { findWithDecryption, findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import {
+  CustomerEntity,
+  CustomerPersonCompanyLink,
+  CustomerPersonProfile,
+} from '../data/entities'
+import { withActiveCustomerPersonCompanyLinkFilter } from './personCompanyLinkTable'
+
+export type PersonCompanySummary = {
+  linkId: string | null
+  companyId: string
+  displayName: string
+  isPrimary: boolean
+  synthetic?: boolean
+}
+
+export async function findDeletedPersonCompanyLink(
+  em: EntityManager,
+  person: CustomerEntity,
+  company: CustomerEntity,
+): Promise<CustomerPersonCompanyLink | null> {
+  const link = await findOneWithDecryption(
+    em,
+    CustomerPersonCompanyLink,
+    {
+      person,
+      company,
+      organizationId: person.organizationId,
+      tenantId: person.tenantId,
+      deletedAt: { $ne: null },
+    } as any,
+    {},
+    { tenantId: person.tenantId, organizationId: person.organizationId },
+  )
+  return link ?? null
+}
+
+async function requireCompany(
+  em: EntityManager,
+  companyId: string,
+  organizationId: string,
+  tenantId: string,
+): Promise<CustomerEntity> {
+  const company = await findOneWithDecryption(em, CustomerEntity, { id: companyId, kind: 'company', deletedAt: null }, {}, { tenantId, organizationId })
+  if (!company) {
+    throw new CrudHttpError(404, { error: 'Company not found' })
+  }
+  if (company.organizationId !== organizationId || company.tenantId !== tenantId) {
+    throw new CrudHttpError(403, { error: 'Cannot link company outside current scope' })
+  }
+  return company
+}
+
+export async function loadPersonCompanyLinks(
+  em: EntityManager,
+  person: CustomerEntity,
+): Promise<CustomerPersonCompanyLink[]> {
+  const where = await withActiveCustomerPersonCompanyLinkFilter(
+    em,
+    { person, organizationId: person.organizationId, tenantId: person.tenantId },
+    'customers.personCompanies.loadPersonCompanyLinks',
+  )
+  return findWithDecryption(
+    em,
+    CustomerPersonCompanyLink,
+    where,
+    { populate: ['company'], orderBy: { isPrimary: 'desc', createdAt: 'asc' } },
+    { tenantId: person.tenantId, organizationId: person.organizationId },
+  )
+}
+
+export function summarizePersonCompanies(
+  profile: CustomerPersonProfile | null,
+  links: CustomerPersonCompanyLink[],
+): PersonCompanySummary[] {
+  if (links.length > 0) {
+    const items: PersonCompanySummary[] = []
+    links.forEach((link) => {
+      const company = typeof link.company === 'string' ? null : link.company
+      if (!company) return
+      items.push({
+        linkId: link.id,
+        companyId: company.id,
+        displayName: company.displayName,
+        isPrimary: Boolean(link.isPrimary),
+      })
+    })
+    return items
+  }
+
+  const fallbackCompany = profile?.company && typeof profile.company !== 'string' ? profile.company : null
+  if (!fallbackCompany) return []
+
+  return [
+    {
+      linkId: fallbackCompany.id,
+      companyId: fallbackCompany.id,
+      displayName: fallbackCompany.displayName,
+      isPrimary: true,
+      synthetic: true,
+    },
+  ]
+}
+
+async function clearPrimaryFlags(em: EntityManager, person: CustomerEntity): Promise<void> {
+  await em.nativeUpdate(
+    CustomerPersonCompanyLink,
+    { person, organizationId: person.organizationId, tenantId: person.tenantId, isPrimary: true },
+    { isPrimary: false },
+  )
+}
+
+function resolveLinkedCompany(link: CustomerPersonCompanyLink): CustomerEntity | null {
+  return typeof link.company === 'string' ? null : link.company
+}
+
+export async function promoteFallbackPrimaryLink(
+  em: EntityManager,
+  person: CustomerEntity,
+  profile: CustomerPersonProfile,
+  links: CustomerPersonCompanyLink[],
+  removedCompanyId?: string | null,
+): Promise<void> {
+  const nextPrimary = links[0] ?? null
+  if (!nextPrimary) {
+    if (
+      !removedCompanyId
+      || (profile.company && typeof profile.company !== 'string' && profile.company.id === removedCompanyId)
+      || profile.company == null
+    ) {
+      profile.company = null
+    }
+    return
+  }
+
+  await clearPrimaryFlags(em, person)
+  nextPrimary.isPrimary = true
+  const nextCompany = resolveLinkedCompany(nextPrimary)
+  if (nextCompany) {
+    profile.company = nextCompany
+  }
+}
+
+export async function syncLegacyPrimaryCompanyLink(
+  em: EntityManager,
+  person: CustomerEntity,
+  profile: CustomerPersonProfile,
+  companyId: string | null | undefined,
+): Promise<void> {
+  const normalizedCompanyId = typeof companyId === 'string' && companyId.trim().length > 0 ? companyId.trim() : null
+  const existingLinks = await loadPersonCompanyLinks(em, person)
+
+  if (!normalizedCompanyId) {
+    if (existingLinks.some((link) => link.isPrimary)) {
+      await clearPrimaryFlags(em, person)
+    }
+    profile.company = null
+    return
+  }
+
+  const company = await requireCompany(em, normalizedCompanyId, person.organizationId, person.tenantId)
+  const currentLink =
+    existingLinks.find((link) => (typeof link.company === 'string' ? link.company : link.company.id) === company.id) ?? null
+
+  if (currentLink) {
+    if (!currentLink.isPrimary) {
+      await clearPrimaryFlags(em, person)
+      currentLink.isPrimary = true
+    } else if (existingLinks.some((link) => link.id !== currentLink.id && link.isPrimary)) {
+      await clearPrimaryFlags(em, person)
+      currentLink.isPrimary = true
+    }
+  } else {
+    await clearPrimaryFlags(em, person)
+    const link = em.create(CustomerPersonCompanyLink, {
+      organizationId: person.organizationId,
+      tenantId: person.tenantId,
+      person,
+      company,
+      isPrimary: true,
+    })
+    em.persist(link)
+  }
+
+  profile.company = company
+}
+
+export async function addPersonCompanyLink(
+  em: EntityManager,
+  person: CustomerEntity,
+  profile: CustomerPersonProfile,
+  companyId: string,
+  options?: { isPrimary?: boolean },
+): Promise<CustomerPersonCompanyLink> {
+  const company = await requireCompany(em, companyId, person.organizationId, person.tenantId)
+  const existingLinks = await loadPersonCompanyLinks(em, person)
+  const makePrimary = Boolean(options?.isPrimary) || existingLinks.length === 0
+  const existing =
+    existingLinks.find((link) => (typeof link.company === 'string' ? link.company : link.company.id) === company.id) ?? null
+
+  if (existing) {
+    if (makePrimary && !existing.isPrimary) {
+      await clearPrimaryFlags(em, person)
+      existing.isPrimary = true
+      profile.company = company
+    }
+    return existing
+  }
+
+  if (makePrimary) {
+    await clearPrimaryFlags(em, person)
+  }
+
+  const deletedLink = await findDeletedPersonCompanyLink(em, person, company)
+  const link = deletedLink ?? em.create(CustomerPersonCompanyLink, {
+    organizationId: person.organizationId,
+    tenantId: person.tenantId,
+    person,
+    company,
+    isPrimary: makePrimary,
+  })
+  if (deletedLink) {
+    deletedLink.deletedAt = null
+    deletedLink.isPrimary = makePrimary
+  }
+  em.persist(link)
+
+  if (makePrimary) {
+    profile.company = company
+  } else if (!profile.company && existingLinks.length === 0) {
+    profile.company = company
+    link.isPrimary = true
+  }
+
+  return link
+}
+
+export async function updatePersonCompanyLink(
+  em: EntityManager,
+  person: CustomerEntity,
+  profile: CustomerPersonProfile,
+  linkId: string,
+  patch: { isPrimary?: boolean },
+): Promise<CustomerPersonCompanyLink | null> {
+  const existingLinks = await loadPersonCompanyLinks(em, person)
+  const link = existingLinks.find((entry) => entry.id === linkId)
+    ?? existingLinks.find((entry) => (typeof entry.company === 'string' ? entry.company : entry.company.id) === linkId)
+    ?? null
+
+  if (!link && profile.company && typeof profile.company !== 'string' && profile.company.id === linkId && patch.isPrimary === false) {
+    profile.company = null
+    return null
+  }
+
+  if (!link) {
+    throw new CrudHttpError(404, { error: 'Company link not found' })
+  }
+
+  if (patch.isPrimary === true) {
+    await clearPrimaryFlags(em, person)
+    link.isPrimary = true
+    const company = resolveLinkedCompany(link)
+    if (company) {
+      profile.company = company
+    }
+  } else if (patch.isPrimary === false) {
+    const linkWasPrimary = link.isPrimary
+    const removedCompanyId = typeof link.company === 'string' ? link.company : link.company.id
+    link.isPrimary = false
+    if (linkWasPrimary) {
+      const remainingLinks = existingLinks.filter((entry) => entry.id !== link.id)
+      await promoteFallbackPrimaryLink(em, person, profile, remainingLinks, removedCompanyId)
+    } else if (profile.company && typeof profile.company !== 'string' && profile.company.id === removedCompanyId) {
+      profile.company = null
+    }
+  }
+
+  return link
+}
+
+export async function removePersonCompanyLink(
+  em: EntityManager,
+  person: CustomerEntity,
+  profile: CustomerPersonProfile,
+  linkId: string,
+): Promise<void> {
+  const existingLinks = await loadPersonCompanyLinks(em, person)
+  const link = existingLinks.find((entry) => entry.id === linkId)
+    ?? existingLinks.find((entry) => (typeof entry.company === 'string' ? entry.company : entry.company.id) === linkId)
+    ?? null
+
+  if (!link) {
+    if (profile.company && typeof profile.company !== 'string' && profile.company.id === linkId) {
+      profile.company = null
+      return
+    }
+    throw new CrudHttpError(404, { error: 'Company link not found' })
+  }
+
+  const removedCompanyId = typeof link.company === 'string' ? link.company : link.company.id
+  const removedWasPrimary = link.isPrimary
+  link.isPrimary = false
+  link.deletedAt = new Date()
+  const remainingLinks = existingLinks.filter((entry) => entry.id !== link.id)
+
+  if (removedWasPrimary) {
+    await promoteFallbackPrimaryLink(em, person, profile, remainingLinks, removedCompanyId)
+  } else if (profile.company && typeof profile.company !== 'string' && profile.company.id === removedCompanyId) {
+    const primary = remainingLinks.find((entry) => entry.isPrimary) ?? null
+    const primaryCompany = primary ? resolveLinkedCompany(primary) : null
+    if (primaryCompany) {
+      profile.company = primaryCompany
+    }
+  }
+}

package/src/modules/customers/lib/personCompanyLinkTable.ts

@@ -0,0 +1,58 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+
+const PERSON_COMPANY_LINKS_TABLE = 'customer_person_company_links'
+const PERSON_COMPANY_LINKS_DELETED_AT_COLUMN = 'deleted_at'
+
+let supportsDeletedAtColumnPromise: Promise<boolean> | null = null
+let warnedAboutMissingDeletedAtColumn = false
+
+type KnexLike = (tableName: string) => {
+  where: (filters: Record<string, unknown>) => {
+    first: () => Promise<unknown>
+  }
+}
+
+function getKnex(em: EntityManager): KnexLike {
+  return (em.getConnection() as unknown as { getKnex: () => KnexLike }).getKnex()
+}
+
+export async function customerPersonCompanyLinksSupportDeletedAt(em: EntityManager): Promise<boolean> {
+  if (typeof (em as { getConnection?: unknown }).getConnection !== 'function') {
+    return true
+  }
+  if (!supportsDeletedAtColumnPromise) {
+    supportsDeletedAtColumnPromise = getKnex(em)('information_schema.columns')
+      .where({
+        table_name: PERSON_COMPANY_LINKS_TABLE,
+        column_name: PERSON_COMPANY_LINKS_DELETED_AT_COLUMN,
+      })
+      .first()
+      .then((row) => !!row)
+      .catch(() => false)
+  }
+  return supportsDeletedAtColumnPromise
+}
+
+export function warnMissingCustomerPersonCompanyLinksDeletedAt(source: string): void {
+  if (warnedAboutMissingDeletedAtColumn) {
+    return
+  }
+  warnedAboutMissingDeletedAtColumn = true
+  console.warn(
+    `[${source}] missing ${PERSON_COMPANY_LINKS_TABLE}.${PERSON_COMPANY_LINKS_DELETED_AT_COLUMN}; ` +
+      'continuing without link soft-delete filtering. Run yarn db:migrate.',
+  )
+}
+
+export async function withActiveCustomerPersonCompanyLinkFilter<T extends Record<string, unknown>>(
+  em: EntityManager,
+  where: T,
+  source: string,
+): Promise<T & { deletedAt?: null }> {
+  const supportsDeletedAt = await customerPersonCompanyLinksSupportDeletedAt(em)
+  if (!supportsDeletedAt) {
+    warnMissingCustomerPersonCompanyLinksDeletedAt(source)
+    return { ...where }
+  }
+  return { ...where, deletedAt: null }
+}