@elevasis/core 0.14.0 → 0.15.1

package/src/organization-model/domains/prospecting.ts

@@ -6,13 +6,35 @@ export const ProspectingLifecycleStageSchema = DisplayMetadataSchema.extend({
   order: z.number().int().min(0)
 })
 
+export const ProspectingBuildTemplateStepSchema = DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  primaryEntity: z.enum(['company', 'contact']),
+  outputs: z.array(z.enum(['company', 'contact', 'export'])).min(1),
+  stageKey: ModelIdSchema,
+  dependsOn: z.array(ModelIdSchema).optional(),
+  dependencyMode: z.literal('per-record-eligibility'),
+  capabilityKey: ModelIdSchema,
+  defaultBatchSize: z.number().int().positive(),
+  maxBatchSize: z.number().int().positive()
+}).refine((step) => step.defaultBatchSize <= step.maxBatchSize, {
+  message: 'defaultBatchSize must be less than or equal to maxBatchSize',
+  path: ['defaultBatchSize']
+})
+
+export const ProspectingBuildTemplateSchema = DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  steps: z.array(ProspectingBuildTemplateStepSchema).min(1)
+})
+
 export const OrganizationModelProspectingSchema = z.object({
   listEntityId: ModelIdSchema,
   companyEntityId: ModelIdSchema,
   contactEntityId: ModelIdSchema,
   description: DescriptionSchema.optional(),
   companyStages: z.array(ProspectingLifecycleStageSchema).min(1),
-  contactStages: z.array(ProspectingLifecycleStageSchema).min(1)
+  contactStages: z.array(ProspectingLifecycleStageSchema).min(1),
+  defaultBuildTemplateId: ModelIdSchema,
+  buildTemplates: z.array(ProspectingBuildTemplateSchema).min(1)
 })
 
 export const DEFAULT_ORGANIZATION_MODEL_PROSPECTING: z.infer<typeof OrganizationModelProspectingSchema> = {
@@ -29,5 +51,186 @@ export const DEFAULT_ORGANIZATION_MODEL_PROSPECTING: z.infer<typeof Organization
     { id: 'verified', label: 'Verified', order: 2 },
     { id: 'personalized', label: 'Personalized', order: 3 },
     { id: 'uploaded', label: 'Uploaded', order: 4 }
+  ],
+  defaultBuildTemplateId: 'local-services',
+  buildTemplates: [
+    {
+      id: 'local-services',
+      label: 'Local Services Prospecting',
+      description:
+        'Curated local-services list build using company sourcing, website analysis, qualification, contact discovery, verification, personalization, and review.',
+      steps: [
+        {
+          id: 'source-companies',
+          label: 'Source companies',
+          primaryEntity: 'company',
+          outputs: ['company'],
+          stageKey: 'populated',
+          dependencyMode: 'per-record-eligibility',
+          capabilityKey: 'lead-gen.company.source',
+          defaultBatchSize: 100,
+          maxBatchSize: 250
+        },
+        {
+          id: 'analyze-websites',
+          label: 'Analyze websites',
+          primaryEntity: 'company',
+          outputs: ['company'],
+          stageKey: 'extracted',
+          dependsOn: ['source-companies'],
+          dependencyMode: 'per-record-eligibility',
+          capabilityKey: 'lead-gen.company.website-extract',
+          defaultBatchSize: 50,
+          maxBatchSize: 100
+        },
+        {
+          id: 'qualify-companies',
+          label: 'Qualify companies',
+          primaryEntity: 'company',
+          outputs: ['company'],
+          stageKey: 'qualified',
+          dependsOn: ['analyze-websites'],
+          dependencyMode: 'per-record-eligibility',
+          capabilityKey: 'lead-gen.company.qualify',
+          defaultBatchSize: 100,
+          maxBatchSize: 250
+        },
+        {
+          id: 'find-contacts',
+          label: 'Find contacts',
+          primaryEntity: 'contact',
+          outputs: ['contact'],
+          stageKey: 'discovered',
+          dependsOn: ['qualify-companies'],
+          dependencyMode: 'per-record-eligibility',
+          capabilityKey: 'lead-gen.contact.discover',
+          defaultBatchSize: 50,
+          maxBatchSize: 100
+        },
+        {
+          id: 'verify-emails',
+          label: 'Verify emails',
+          primaryEntity: 'contact',
+          outputs: ['contact'],
+          stageKey: 'verified',
+          dependsOn: ['find-contacts'],
+          dependencyMode: 'per-record-eligibility',
+          capabilityKey: 'lead-gen.contact.verify-email',
+          defaultBatchSize: 100,
+          maxBatchSize: 500
+        },
+        {
+          id: 'personalize',
+          label: 'Personalize',
+          primaryEntity: 'contact',
+          outputs: ['contact'],
+          stageKey: 'personalized',
+          dependsOn: ['verify-emails'],
+          dependencyMode: 'per-record-eligibility',
+          capabilityKey: 'lead-gen.contact.personalize',
+          defaultBatchSize: 25,
+          maxBatchSize: 100
+        },
+        {
+          id: 'review',
+          label: 'Review',
+          primaryEntity: 'contact',
+          outputs: ['export'],
+          stageKey: 'uploaded',
+          dependsOn: ['personalize'],
+          dependencyMode: 'per-record-eligibility',
+          capabilityKey: 'lead-gen.review.outreach-ready',
+          defaultBatchSize: 25,
+          maxBatchSize: 100
+        }
+      ]
+    },
+    {
+      id: 'dtc-subscription-apollo-clickup',
+      label: 'DTC Subscription Apollo Export',
+      description:
+        'Prospecting pipeline for DTC subscription or subscription-ready brands where Apollo is the source and contact-enrichment layer, Elevasis handles company research and fit scoring, and approved leads export as an approved lead list.',
+      steps: [
+        {
+          id: 'import-apollo-search',
+          label: 'Import Apollo search',
+          description: 'Pull companies and seed contact data from a predefined Apollo search or list.',
+          primaryEntity: 'company',
+          outputs: ['company', 'contact'],
+          stageKey: 'populated',
+          dependencyMode: 'per-record-eligibility',
+          capabilityKey: 'lead-gen.company.apollo-import',
+          defaultBatchSize: 250,
+          maxBatchSize: 1000
+        },
+        {
+          id: 'analyze-websites',
+          label: 'Analyze websites',
+          description: 'Extract subscription, product, retention, and tech-stack signals from each brand website.',
+          primaryEntity: 'company',
+          outputs: ['company'],
+          stageKey: 'extracted',
+          dependsOn: ['import-apollo-search'],
+          dependencyMode: 'per-record-eligibility',
+          capabilityKey: 'lead-gen.company.website-extract',
+          defaultBatchSize: 50,
+          maxBatchSize: 100
+        },
+        {
+          id: 'score-dtc-fit',
+          label: 'Score DTC fit',
+          description:
+            'Classify subscription potential, consumable-product fit, retention maturity, and disqualifiers.',
+          primaryEntity: 'company',
+          outputs: ['company'],
+          stageKey: 'qualified',
+          dependsOn: ['analyze-websites'],
+          dependencyMode: 'per-record-eligibility',
+          capabilityKey: 'lead-gen.company.dtc-subscription-qualify',
+          defaultBatchSize: 100,
+          maxBatchSize: 250
+        },
+        {
+          id: 'enrich-decision-makers',
+          label: 'Enrich decision-makers',
+          description:
+            'Use Apollo to find qualified contacts such as founders, retention leads, lifecycle leads, and marketing owners.',
+          primaryEntity: 'contact',
+          outputs: ['contact'],
+          stageKey: 'discovered',
+          dependsOn: ['score-dtc-fit'],
+          dependencyMode: 'per-record-eligibility',
+          capabilityKey: 'lead-gen.contact.apollo-decision-maker-enrich',
+          defaultBatchSize: 100,
+          maxBatchSize: 250
+        },
+        {
+          id: 'verify-emails',
+          label: 'Verify emails',
+          description: 'Verify deliverability before the QC and handoff step.',
+          primaryEntity: 'contact',
+          outputs: ['contact'],
+          stageKey: 'verified',
+          dependsOn: ['enrich-decision-makers'],
+          dependencyMode: 'per-record-eligibility',
+          capabilityKey: 'lead-gen.contact.verify-email',
+          defaultBatchSize: 250,
+          maxBatchSize: 500
+        },
+        {
+          id: 'review-and-export',
+          label: 'Review and export',
+          description: 'Operator QC approves or rejects leads, then approved records are exported as a lead list.',
+          primaryEntity: 'company',
+          outputs: ['export'],
+          stageKey: 'uploaded',
+          dependsOn: ['verify-emails'],
+          dependencyMode: 'per-record-eligibility',
+          capabilityKey: 'lead-gen.export.list',
+          defaultBatchSize: 100,
+          maxBatchSize: 250
+        }
+      ]
+    }
   ]
 }

package/src/organization-model/domains/sales.test.ts

@@ -0,0 +1,218 @@
+import { describe, it, expect } from 'vitest'
+import {
+  CRM_PIPELINE_DEFINITION,
+  CRM_DISCOVERY_REPLIED_STATE,
+  CRM_DISCOVERY_LINK_SENT_STATE,
+  CRM_DISCOVERY_NUDGING_STATE,
+  CRM_DISCOVERY_BOOKING_CANCELLED_STATE,
+  CRM_REPLY_SENT_STATE,
+  CRM_FOLLOWUP_1_SENT_STATE,
+  CRM_FOLLOWUP_2_SENT_STATE,
+  CRM_FOLLOWUP_3_SENT_STATE,
+  CRM_PRIORITY_BUCKETS,
+  DEFAULT_CRM_PRIORITY_RULE_CONFIG,
+  getValidStatesForStage,
+  findPipeline,
+  ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE,
+  ACQ_LIST_COMPANIES_LEAD_GEN_PIPELINE,
+  LEAD_GEN_PIPELINE_DEFINITIONS
+} from './sales'
+
+describe('CRM_PIPELINE_DEFINITION', () => {
+  it('has pipelineKey "crm"', () => {
+    expect(CRM_PIPELINE_DEFINITION.pipelineKey).toBe('crm')
+  })
+
+  it('has entityKey "crm.deal"', () => {
+    expect(CRM_PIPELINE_DEFINITION.entityKey).toBe('crm.deal')
+  })
+
+  it('has exactly 6 stages', () => {
+    expect(CRM_PIPELINE_DEFINITION.stages).toHaveLength(6)
+  })
+
+  it('stage keys are interested, proposal, closing, closed_won, closed_lost, nurturing in order', () => {
+    const keys = CRM_PIPELINE_DEFINITION.stages.map((s) => s.stageKey)
+    expect(keys).toEqual(['interested', 'proposal', 'closing', 'closed_won', 'closed_lost', 'nurturing'])
+  })
+
+  it('interested stage has exactly 8 states', () => {
+    const interested = CRM_PIPELINE_DEFINITION.stages.find((s) => s.stageKey === 'interested')
+    expect(interested?.states).toHaveLength(8)
+  })
+
+  it('interested stage contains all 8 expected state constants', () => {
+    const interested = CRM_PIPELINE_DEFINITION.stages.find((s) => s.stageKey === 'interested')!
+    const stateKeys = interested.states.map((s) => s.stateKey)
+    expect(stateKeys).toContain(CRM_DISCOVERY_REPLIED_STATE.stateKey)
+    expect(stateKeys).toContain(CRM_DISCOVERY_LINK_SENT_STATE.stateKey)
+    expect(stateKeys).toContain(CRM_DISCOVERY_NUDGING_STATE.stateKey)
+    expect(stateKeys).toContain(CRM_DISCOVERY_BOOKING_CANCELLED_STATE.stateKey)
+    expect(stateKeys).toContain(CRM_REPLY_SENT_STATE.stateKey)
+    expect(stateKeys).toContain(CRM_FOLLOWUP_1_SENT_STATE.stateKey)
+    expect(stateKeys).toContain(CRM_FOLLOWUP_2_SENT_STATE.stateKey)
+    expect(stateKeys).toContain(CRM_FOLLOWUP_3_SENT_STATE.stateKey)
+  })
+
+  it('interested stage states reference the exported constants by identity', () => {
+    const interested = CRM_PIPELINE_DEFINITION.stages.find((s) => s.stageKey === 'interested')!
+    expect(interested.states).toContain(CRM_DISCOVERY_REPLIED_STATE)
+    expect(interested.states).toContain(CRM_FOLLOWUP_3_SENT_STATE)
+  })
+
+  it.each(['proposal', 'closing', 'closed_won', 'closed_lost', 'nurturing'])(
+    '%s stage has an empty states array',
+    (stageKey) => {
+      const stage = CRM_PIPELINE_DEFINITION.stages.find((s) => s.stageKey === stageKey)
+      expect(stage).toBeDefined()
+      expect(stage?.states).toHaveLength(0)
+    }
+  )
+
+  it('closed_won stage has empty states array', () => {
+    const stage = CRM_PIPELINE_DEFINITION.stages.find((s) => s.stageKey === 'closed_won')
+    expect(stage?.states).toEqual([])
+  })
+
+  it('closed_lost stage has empty states array', () => {
+    const stage = CRM_PIPELINE_DEFINITION.stages.find((s) => s.stageKey === 'closed_lost')
+    expect(stage?.states).toEqual([])
+  })
+})
+
+describe('CRM state constant shapes', () => {
+  it('CRM_DISCOVERY_REPLIED_STATE has correct stateKey and label', () => {
+    expect(CRM_DISCOVERY_REPLIED_STATE).toEqual({ stateKey: 'discovery_replied', label: 'Discovery Replied' })
+  })
+
+  it('CRM_FOLLOWUP_1_SENT_STATE has correct stateKey and label', () => {
+    expect(CRM_FOLLOWUP_1_SENT_STATE).toEqual({ stateKey: 'followup_1_sent', label: 'Follow-up 1 Sent' })
+  })
+
+  it('CRM_FOLLOWUP_2_SENT_STATE has correct stateKey and label', () => {
+    expect(CRM_FOLLOWUP_2_SENT_STATE).toEqual({ stateKey: 'followup_2_sent', label: 'Follow-up 2 Sent' })
+  })
+
+  it('CRM_FOLLOWUP_3_SENT_STATE has correct stateKey and label', () => {
+    expect(CRM_FOLLOWUP_3_SENT_STATE).toEqual({ stateKey: 'followup_3_sent', label: 'Follow-up 3 Sent' })
+  })
+})
+
+describe('DEFAULT_CRM_PRIORITY_RULE_CONFIG', () => {
+  it('defines the canonical CRM priority buckets in sort order', () => {
+    expect(CRM_PRIORITY_BUCKETS.map((bucket) => bucket.bucketKey)).toEqual([
+      'needs_response',
+      'follow_up_due',
+      'waiting',
+      'stale',
+      'closed_low'
+    ])
+    expect(CRM_PRIORITY_BUCKETS.map((bucket) => bucket.rank)).toEqual([10, 20, 30, 40, 50])
+  })
+
+  it('includes display metadata for each bucket', () => {
+    for (const bucket of CRM_PRIORITY_BUCKETS) {
+      expect(bucket.label).toEqual(expect.any(String))
+      expect(bucket.rank).toEqual(expect.any(Number))
+      expect(bucket.color).toEqual(expect.any(String))
+    }
+  })
+
+  it('maps CRM states and closed stages into priority rules', () => {
+    expect(DEFAULT_CRM_PRIORITY_RULE_CONFIG.closedStageKeys).toEqual(['closed_won', 'closed_lost'])
+    expect(DEFAULT_CRM_PRIORITY_RULE_CONFIG.followUpAfterDaysByStateKey.discovery_link_sent).toBe(3)
+    expect(DEFAULT_CRM_PRIORITY_RULE_CONFIG.staleAfterDays).toBeGreaterThan(0)
+  })
+})
+
+describe('getValidStatesForStage', () => {
+  it('returns all 8 states for the interested stage', () => {
+    const states = getValidStatesForStage(CRM_PIPELINE_DEFINITION, 'interested')
+    expect(states).toHaveLength(8)
+    expect(states.map((s) => s.stateKey)).toContain('discovery_replied')
+    expect(states.map((s) => s.stateKey)).toContain('followup_3_sent')
+  })
+
+  it('returns empty array for the proposal stage (no states defined)', () => {
+    const states = getValidStatesForStage(CRM_PIPELINE_DEFINITION, 'proposal')
+    expect(states).toEqual([])
+  })
+
+  it('returns empty array for the closing stage (no states defined)', () => {
+    const states = getValidStatesForStage(CRM_PIPELINE_DEFINITION, 'closing')
+    expect(states).toEqual([])
+  })
+
+  it('returns empty array for closed_won stage', () => {
+    const states = getValidStatesForStage(CRM_PIPELINE_DEFINITION, 'closed_won')
+    expect(states).toEqual([])
+  })
+
+  it('returns empty array for closed_lost stage', () => {
+    const states = getValidStatesForStage(CRM_PIPELINE_DEFINITION, 'closed_lost')
+    expect(states).toEqual([])
+  })
+
+  it('returns empty array for nurturing stage (no states defined)', () => {
+    const states = getValidStatesForStage(CRM_PIPELINE_DEFINITION, 'nurturing')
+    expect(states).toEqual([])
+  })
+
+  it('returns empty array for an unknown stage key', () => {
+    const states = getValidStatesForStage(CRM_PIPELINE_DEFINITION, 'unknown_stage')
+    expect(states).toEqual([])
+  })
+
+  it('returns empty array for an empty string stage key', () => {
+    const states = getValidStatesForStage(CRM_PIPELINE_DEFINITION, '')
+    expect(states).toEqual([])
+  })
+
+  it('is case-sensitive — "Interested" does not match "interested"', () => {
+    const states = getValidStatesForStage(CRM_PIPELINE_DEFINITION, 'Interested')
+    expect(states).toEqual([])
+  })
+
+  it('works with the lead-gen member pipeline for known stage', () => {
+    const states = getValidStatesForStage(ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE, 'outreach')
+    expect(states.length).toBeGreaterThan(0)
+    expect(states.map((s) => s.stateKey)).toContain('personalized')
+  })
+
+  it('works with the lead-gen member pipeline for unknown stage', () => {
+    const states = getValidStatesForStage(ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE, 'nonexistent')
+    expect(states).toEqual([])
+  })
+})
+
+describe('findPipeline', () => {
+  it('finds a pipeline by pipelineKey when present', () => {
+    const found = findPipeline(LEAD_GEN_PIPELINE_DEFINITIONS['acq.list-member'], 'lead-gen')
+    expect(found).toBe(ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE)
+  })
+
+  it('returns undefined for an unknown pipelineKey', () => {
+    const found = findPipeline(LEAD_GEN_PIPELINE_DEFINITIONS['acq.list-member'], 'crm')
+    expect(found).toBeUndefined()
+  })
+
+  it('returns undefined for an empty array', () => {
+    const found = findPipeline([], 'lead-gen')
+    expect(found).toBeUndefined()
+  })
+})
+
+describe('LEAD_GEN_PIPELINE_DEFINITIONS', () => {
+  it('has entries for acq.list-member and acq.list-company', () => {
+    expect(LEAD_GEN_PIPELINE_DEFINITIONS).toHaveProperty('acq.list-member')
+    expect(LEAD_GEN_PIPELINE_DEFINITIONS).toHaveProperty('acq.list-company')
+  })
+
+  it('acq.list-member entry contains the ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE', () => {
+    expect(LEAD_GEN_PIPELINE_DEFINITIONS['acq.list-member']).toContain(ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE)
+  })
+
+  it('acq.list-company entry contains the ACQ_LIST_COMPANIES_LEAD_GEN_PIPELINE', () => {
+    expect(LEAD_GEN_PIPELINE_DEFINITIONS['acq.list-company']).toContain(ACQ_LIST_COMPANIES_LEAD_GEN_PIPELINE)
+  })
+})