@elevasis/core 0.14.0 → 0.15.1

package/src/business/acquisition/activity-events.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod'
 
 // ---------------------------------------------------------------------------
-// Platform event member schemas (8 members — closed union, stays in @repo/core)
+// Platform event member schemas (9 members — closed union, stays in @repo/core)
 //
 // Domain-specific events (reply_received, booking_nudge_sent, etc.) live in
 // external/elevasis/operations as CrmDomainActivityEventSchema.
@@ -66,8 +66,16 @@ const DealCreatedEventSchema = z.object({
   timestamp: z.string().datetime()
 })
 
+const ActionFailedEventSchema = z.object({
+  type: z.literal('action_failed'),
+  timestamp: z.string().datetime(),
+  actionKey: z.string(),
+  errorMessage: z.string(),
+  payload: z.record(z.string(), z.unknown()).optional()
+})
+
 // ---------------------------------------------------------------------------
-// Union — closed 8-member platform union
+// Union — closed 9-member platform union
 // ---------------------------------------------------------------------------
 
 export const ActivityEventSchema = z.discriminatedUnion('type', [
@@ -78,7 +86,8 @@ export const ActivityEventSchema = z.discriminatedUnion('type', [
   ApprovalResolvedEventSchema,
   ApprovalStaleEventSchema,
   TaskCreatedEventSchema,
-  DealCreatedEventSchema
+  DealCreatedEventSchema,
+  ActionFailedEventSchema
 ])
 
 export type ActivityEvent = z.infer<typeof ActivityEventSchema>

package/src/business/acquisition/api-schemas.test.ts

@@ -1,5 +1,10 @@
 import { describe, expect, it } from 'vitest'
-import { LEAD_GEN_PIPELINE_DEFINITIONS, LEAD_GEN_STAGE_CATALOG } from '../../organization-model/domains/sales'
+import {
+  DEFAULT_CRM_PRIORITY_RULE_CONFIG,
+  LEAD_GEN_PIPELINE_DEFINITIONS,
+  LEAD_GEN_STAGE_CATALOG
+} from '../../organization-model/domains/sales'
+import { CrmPriorityOverrideSchema, evaluateCrmDealPriority, resolveCrmPriorityRuleConfig } from './crm-priority'
 import {
   AddCompaniesToListRequestSchema,
   AddContactsToListRequestSchema,
@@ -15,6 +20,7 @@ import {
   CreateDealTaskRequestSchema,
   CreateListRequestSchema,
   DealDetailResponseSchema,
+  DealListItemSchema,
   DealListResponseSchema,
   DealNoteResponseSchema,
   DealStageSchema,
@@ -44,6 +50,15 @@ import {
 
 const VALID_UUID = '00000000-0000-4000-8000-000000000001'
 const ISO_TS = '2026-04-27T12:34:56.000Z'
+const PRIORITY = {
+  bucketKey: 'waiting' as const,
+  rank: 30,
+  label: 'Waiting',
+  color: 'blue',
+  reason: 'No immediate response or follow-up is due.',
+  latestActivityAt: ISO_TS,
+  nextActionAt: null
+}
 
 // ---------------------------------------------------------------------------
 // DealStageSchema
@@ -414,10 +429,251 @@ describe('UpdateContactRequestSchema', () => {
   })
 })
 
+// ---------------------------------------------------------------------------
+// CRM priority override contract
+// ---------------------------------------------------------------------------
+
+describe('CrmPriorityOverrideSchema', () => {
+  it('accepts a valid partial organization override', () => {
+    const result = CrmPriorityOverrideSchema.safeParse({
+      enabled: true,
+      staleAfterDays: 10,
+      bucketOrder: ['needs_response', 'follow_up_due', 'stale', 'waiting', 'closed_low'],
+      buckets: {
+        needs_response: { label: 'Reply Now', color: 'red', rank: 5 },
+        waiting: { label: 'Pending' }
+      },
+      followUpAfterDaysByStateKey: {
+        discovery_link_sent: 2,
+        custom_state: 4
+      },
+      closedStageKeys: ['closed_won', 'closed_lost']
+    })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects needsResponseStateKeys and needsResponseActivityTypes (removed fields)', () => {
+    expect(CrmPriorityOverrideSchema.safeParse({ needsResponseStateKeys: ['x'] }).success).toBe(false)
+    expect(CrmPriorityOverrideSchema.safeParse({ needsResponseActivityTypes: ['x'] }).success).toBe(false)
+  })
+
+  it('accepts sparse partial overrides', () => {
+    const result = CrmPriorityOverrideSchema.safeParse({
+      staleAfterDays: 21,
+      buckets: {
+        stale: { color: 'yellow' }
+      }
+    })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects invalid unknown input shapes', () => {
+    expect(CrmPriorityOverrideSchema.safeParse('bad').success).toBe(false)
+    expect(CrmPriorityOverrideSchema.safeParse({ staleAfterDays: -1 }).success).toBe(false)
+    expect(CrmPriorityOverrideSchema.safeParse({ buckets: { invalid_bucket: { label: 'Bad' } } }).success).toBe(false)
+  })
+})
+
+describe('resolveCrmPriorityRuleConfig', () => {
+  it('merges valid organization config overrides with default rules', () => {
+    const resolved = resolveCrmPriorityRuleConfig({
+      crm: {
+        priority: {
+          staleAfterDays: 7,
+          bucketOrder: ['stale', 'needs_response'],
+          buckets: {
+            stale: { label: 'Dormant', color: 'yellow' },
+            needs_response: { rank: 3 }
+          },
+          followUpAfterDaysByStateKey: { discovery_link_sent: 1 },
+          closedStageKeys: ['won', 'lost']
+        }
+      }
+    })
+
+    expect(resolved.enabled).toBe(true)
+    expect(resolved.staleAfterDays).toBe(7)
+    expect(resolved.closedStageKeys).toEqual(['won', 'lost'])
+    expect(resolved.followUpAfterDaysByStateKey.discovery_link_sent).toBe(1)
+    expect(resolved.followUpAfterDaysByStateKey.reply_sent).toBe(
+      DEFAULT_CRM_PRIORITY_RULE_CONFIG.followUpAfterDaysByStateKey.reply_sent
+    )
+
+    const staleBucket = resolved.buckets.find((bucket) => bucket.bucketKey === 'stale')
+    expect(staleBucket).toMatchObject({ label: 'Dormant', color: 'yellow', rank: 10 })
+
+    const needsResponseBucket = resolved.buckets.find((bucket) => bucket.bucketKey === 'needs_response')
+    expect(needsResponseBucket?.rank).toBe(3)
+  })
+
+  it('falls back to defaults for missing or invalid input', () => {
+    expect(resolveCrmPriorityRuleConfig(undefined)).toMatchObject({
+      enabled: true,
+      staleAfterDays: DEFAULT_CRM_PRIORITY_RULE_CONFIG.staleAfterDays,
+      closedStageKeys: DEFAULT_CRM_PRIORITY_RULE_CONFIG.closedStageKeys
+    })
+
+    expect(resolveCrmPriorityRuleConfig({ staleAfterDays: 0 })).toMatchObject({
+      enabled: true,
+      staleAfterDays: DEFAULT_CRM_PRIORITY_RULE_CONFIG.staleAfterDays,
+      closedStageKeys: DEFAULT_CRM_PRIORITY_RULE_CONFIG.closedStageKeys
+    })
+  })
+})
+
 // ---------------------------------------------------------------------------
 // Response schemas — smoke-level forward-compat checks
 // ---------------------------------------------------------------------------
 
+describe('evaluateCrmDealPriority', () => {
+  const now = '2026-04-30T12:00:00.000Z'
+  const baseInput = {
+    stage_key: 'interested',
+    state_key: null,
+    activity_log: [],
+    updated_at: '2026-04-29T12:00:00.000Z',
+    created_at: '2026-04-01T12:00:00.000Z'
+  }
+
+  it('returns needs_response when the lead replied last (ownership us)', () => {
+    // A reply_received inbound event makes ownership === 'us' → needs_response
+    const priority = evaluateCrmDealPriority(
+      {
+        ...baseInput,
+        state_key: 'discovery_replied',
+        activity_log: [{ type: 'reply_received', timestamp: '2026-04-29T10:00:00.000Z' }]
+      },
+      { now }
+    )
+    expect(priority.bucketKey).toBe('needs_response')
+    expect(priority.rank).toBe(10)
+    expect(priority.reason).toBe('Lead replied last — we owe the next move.')
+  })
+
+  it('returns follow_up_due when configured follow-up window has elapsed', () => {
+    const priority = evaluateCrmDealPriority(
+      {
+        ...baseInput,
+        state_key: 'discovery_link_sent',
+        activity_log: [{ type: 'action_taken', timestamp: '2026-04-25T12:00:00.000Z', actionKey: 'send_link' }],
+        updated_at: '2026-04-25T12:00:00.000Z'
+      },
+      { now }
+    )
+
+    expect(priority.bucketKey).toBe('follow_up_due')
+    expect(priority.nextActionAt).toBe('2026-04-28T12:00:00.000Z')
+  })
+
+  it('returns waiting when the next action is still in the future', () => {
+    const priority = evaluateCrmDealPriority(
+      {
+        ...baseInput,
+        state_key: 'discovery_link_sent',
+        activity_log: [{ type: 'action_taken', timestamp: '2026-04-29T12:00:00.000Z', actionKey: 'send_link' }],
+        updated_at: '2026-04-29T12:00:00.000Z'
+      },
+      { now }
+    )
+
+    expect(priority.bucketKey).toBe('waiting')
+    expect(priority.nextActionAt).toBe('2026-05-02T12:00:00.000Z')
+  })
+
+  it('returns stale when there is no recent meaningful activity', () => {
+    const priority = evaluateCrmDealPriority(
+      { ...baseInput, updated_at: '2026-04-01T12:00:00.000Z', created_at: '2026-04-01T12:00:00.000Z' },
+      { now }
+    )
+
+    expect(priority.bucketKey).toBe('stale')
+  })
+
+  it('returns closed_low for closed stages', () => {
+    const priority = evaluateCrmDealPriority({ ...baseInput, stage_key: 'closed_lost' }, { now })
+    expect(priority.bucketKey).toBe('closed_low')
+    expect(priority.rank).toBe(50)
+  })
+
+  it('ignores malformed activity entries without throwing', () => {
+    const priority = evaluateCrmDealPriority(
+      {
+        ...baseInput,
+        activity_log: [null, 'bad', { type: 'reply_received', timestamp: 'not-a-date' }, { other: true }],
+        updated_at: '2026-04-29T12:00:00.000Z'
+      },
+      { now }
+    )
+
+    expect(priority.bucketKey).toBe('waiting')
+    expect(priority.latestActivityAt).toBe('2026-04-29T12:00:00.000Z')
+  })
+
+  it('returns a neutral waiting priority when CRM priority is disabled', () => {
+    const config = resolveCrmPriorityRuleConfig({
+      enabled: false,
+      buckets: {
+        waiting: { label: 'Priority Off', color: 'gray', rank: 999 }
+      }
+    })
+    const priority = evaluateCrmDealPriority(
+      {
+        ...baseInput,
+        state_key: 'discovery_replied',
+        activity_log: [{ type: 'reply_received', timestamp: '2026-04-30T10:00:00.000Z' }]
+      },
+      { config, now }
+    )
+
+    expect(priority).toMatchObject({
+      bucketKey: 'waiting',
+      label: 'Priority Off',
+      color: 'gray',
+      rank: 999,
+      reason: 'CRM priority evaluation is disabled.',
+      nextActionAt: null
+    })
+  })
+})
+
+describe('DealListItemSchema', () => {
+  it('accepts a deal with a derived priority object', () => {
+    const result = DealListItemSchema.safeParse({
+      id: VALID_UUID,
+      organization_id: VALID_UUID,
+      contact_id: null,
+      contact_email: 'test@example.com',
+      pipeline_key: 'crm',
+      stage_key: 'interested',
+      state_key: 'discovery_link_sent',
+      activity_log: [],
+      discovery_data: null,
+      discovery_submitted_at: null,
+      discovery_submitted_by: null,
+      proposal_data: null,
+      proposal_sent_at: null,
+      proposal_pdf_url: null,
+      signature_envelope_id: null,
+      source_list_id: null,
+      source_type: null,
+      initial_fee: null,
+      monthly_fee: null,
+      closed_lost_at: null,
+      closed_lost_reason: null,
+      created_at: ISO_TS,
+      updated_at: ISO_TS,
+      priority: PRIORITY,
+      ownership: null,
+      nextAction: null,
+      contact: null
+    })
+
+    expect(result.success).toBe(true)
+  })
+})
+
 describe('DealDetailResponseSchema (forward-compat)', () => {
   const baseDeal = {
     id: VALID_UUID,
@@ -443,13 +699,39 @@ describe('DealDetailResponseSchema (forward-compat)', () => {
     closed_lost_reason: null,
     created_at: ISO_TS,
     updated_at: ISO_TS,
-    contact: null
+    priority: PRIORITY,
+    ownership: null,
+    nextAction: null,
+    contact: null,
+    conversation: {
+      messages: []
+    }
   }
 
-  it('accepts a deal with null contact', () => {
+  it('accepts a deal with null contact and an empty conversation', () => {
     expect(DealDetailResponseSchema.safeParse(baseDeal).success).toBe(true)
   })
 
+  it('accepts conversation messages with preview-derived bodies', () => {
+    const withConversation = {
+      ...baseDeal,
+      conversation: {
+        messages: [
+          {
+            id: 'message-1',
+            direction: 'inbound',
+            fromEmail: 'lead@example.com',
+            toEmail: 'sender@example.com',
+            subject: 'Re: quick thought',
+            body: 'Sure, send it over.',
+            sentAt: ISO_TS
+          }
+        ]
+      }
+    }
+    expect(DealDetailResponseSchema.safeParse(withConversation).success).toBe(true)
+  })
+
   it('accepts a deal with nested contact that has null company', () => {
     const withContact = {
       ...baseDeal,
@@ -668,6 +950,19 @@ describe('CreateListRequestSchema', () => {
     expect(CreateListRequestSchema.safeParse({ name: 'X', status: 'draft' }).success).toBe(true)
   })
 
+  it('accepts a known prospecting build template id', () => {
+    const result = CreateListRequestSchema.safeParse({
+      name: 'DTC Subscription Brands',
+      buildTemplateId: 'dtc-subscription-apollo-clickup'
+    })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects an unknown prospecting build template id', () => {
+    expect(CreateListRequestSchema.safeParse({ name: 'X', buildTemplateId: 'not-a-template' }).success).toBe(false)
+  })
+
   it('rejects an invalid status', () => {
     expect(CreateListRequestSchema.safeParse({ name: 'X', status: 'active' }).success).toBe(false)
   })
@@ -710,6 +1005,23 @@ describe('UpdateListRequestSchema', () => {
     expect(UpdateListRequestSchema.safeParse({ batchIds: ['batch-1'] }).success).toBe(true)
   })
 
+  it('accepts buildTemplateId when the change is explicitly confirmed', () => {
+    expect(
+      UpdateListRequestSchema.safeParse({
+        buildTemplateId: 'dtc-subscription-apollo-clickup',
+        confirmBuildTemplateChange: true
+      }).success
+    ).toBe(true)
+  })
+
+  it('rejects buildTemplateId without explicit confirmation', () => {
+    expect(
+      UpdateListRequestSchema.safeParse({
+        buildTemplateId: 'dtc-subscription-apollo-clickup'
+      }).success
+    ).toBe(false)
+  })
+
   it('rejects unknown fields (strict mode)', () => {
     expect(UpdateListRequestSchema.safeParse({ name: 'X', extra: 'bad' }).success).toBe(false)
   })
@@ -1115,7 +1427,6 @@ describe('AcqListResponseSchema (forward-compat)', () => {
     organizationId: VALID_UUID,
     name: 'Test List',
     description: null,
-    type: 'standard',
     batchIds: [],
     instantlyCampaignId: null,
     status: 'draft' as const,