@elevasis/core 0.12.0 → 0.14.0

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

@@ -0,0 +1,1180 @@
+import { describe, expect, it } from 'vitest'
+import { LEAD_GEN_PIPELINE_DEFINITIONS, LEAD_GEN_STAGE_CATALOG } from '../../organization-model/domains/sales'
+import {
+  AddCompaniesToListRequestSchema,
+  AddContactsToListRequestSchema,
+  AcqArtifactOwnerKindSchema,
+  AcqContactResponseSchema,
+  AcqContactStatusSchema,
+  AcqEmailValidSchema,
+  AcqListResponseSchema,
+  CreateArtifactRequestSchema,
+  CreateCompanyRequestSchema,
+  CreateContactRequestSchema,
+  CreateDealNoteRequestSchema,
+  CreateDealTaskRequestSchema,
+  CreateListRequestSchema,
+  DealDetailResponseSchema,
+  DealListResponseSchema,
+  DealNoteResponseSchema,
+  DealStageSchema,
+  DealTaskResponseSchema,
+  ExecuteActionRequestSchema,
+  IcpRubricSchema,
+  ListArtifactsQuerySchema,
+  ListCompaniesQuerySchema,
+  ListContactsQuerySchema,
+  ListDealsQuerySchema,
+  ListDealTasksDueQuerySchema,
+  ListMembersQuerySchema,
+  ListStatusSchema,
+  PipelineStageSchema,
+  ScrapingConfigSchema,
+  TransitionItemRequestSchema,
+  UpdateCompanyRequestSchema,
+  UpdateContactRequestSchema,
+  UpdateListConfigRequestSchema,
+  UpdateListRequestSchema,
+  UpdateListStatusRequestSchema
+} from './api-schemas'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const VALID_UUID = '00000000-0000-4000-8000-000000000001'
+const ISO_TS = '2026-04-27T12:34:56.000Z'
+
+// ---------------------------------------------------------------------------
+// DealStageSchema
+// ---------------------------------------------------------------------------
+
+describe('DealStageSchema', () => {
+  it.each(['interested', 'proposal', 'closing', 'closed_won', 'closed_lost', 'nurturing'])(
+    'accepts canonical stage "%s"',
+    (stage) => {
+      expect(DealStageSchema.safeParse(stage).success).toBe(true)
+    }
+  )
+
+  it('rejects an unknown stage value', () => {
+    expect(DealStageSchema.safeParse('open').success).toBe(false)
+    expect(DealStageSchema.safeParse('').success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// TransitionItemRequestSchema
+// ---------------------------------------------------------------------------
+
+describe('TransitionItemRequestSchema', () => {
+  const valid = {
+    pipelineKey: 'default',
+    stageKey: 'interested',
+    stateKey: null
+  }
+
+  it('accepts a minimal valid payload', () => {
+    expect(TransitionItemRequestSchema.safeParse(valid).success).toBe(true)
+  })
+
+  it('accepts stateKey as null', () => {
+    const result = TransitionItemRequestSchema.safeParse({ ...valid, stateKey: null })
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts stateKey as a string', () => {
+    const result = TransitionItemRequestSchema.safeParse({ ...valid, stateKey: 'discovery_replied' })
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts stateKey as undefined (optional)', () => {
+    const { stateKey: _omit, ...withoutState } = valid
+    const result = TransitionItemRequestSchema.safeParse(withoutState)
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts a valid ISO datetime for expectedUpdatedAt', () => {
+    const result = TransitionItemRequestSchema.safeParse({ ...valid, expectedUpdatedAt: ISO_TS })
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects a non-ISO datetime for expectedUpdatedAt', () => {
+    const result = TransitionItemRequestSchema.safeParse({ ...valid, expectedUpdatedAt: 'not-a-date' })
+    expect(result.success).toBe(false)
+  })
+
+  it('accepts all canonical CRM deal stages', () => {
+    const stages = ['interested', 'proposal', 'closing', 'closed_won', 'closed_lost', 'nurturing']
+    for (const stageKey of stages) {
+      expect(TransitionItemRequestSchema.safeParse({ pipelineKey: 'default', stageKey, stateKey: null }).success).toBe(
+        true
+      )
+    }
+  })
+
+  it('accepts lead-gen pipeline stage/state pairs from LEAD_GEN_PIPELINE_DEFINITIONS', () => {
+    for (const pipelineDefinitions of Object.values(LEAD_GEN_PIPELINE_DEFINITIONS)) {
+      for (const pipeline of pipelineDefinitions) {
+        for (const stage of pipeline.stages) {
+          for (const state of stage.states) {
+            expect(
+              TransitionItemRequestSchema.safeParse({
+                pipelineKey: pipeline.pipelineKey,
+                stageKey: stage.stageKey,
+                stateKey: state.stateKey
+              }).success
+            ).toBe(true)
+          }
+        }
+      }
+    }
+  })
+
+  it('rejects an empty pipelineKey', () => {
+    const result = TransitionItemRequestSchema.safeParse({ ...valid, pipelineKey: '' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects an empty stageKey', () => {
+    const result = TransitionItemRequestSchema.safeParse({ ...valid, stageKey: '' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects unknown top-level fields (strict mode)', () => {
+    const result = TransitionItemRequestSchema.safeParse({ ...valid, unknownField: 'x' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects missing pipelineKey', () => {
+    const { pipelineKey: _omit, ...missing } = valid
+    const result = TransitionItemRequestSchema.safeParse(missing)
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects missing stageKey', () => {
+    const { stageKey: _omit, ...missing } = valid
+    const result = TransitionItemRequestSchema.safeParse(missing)
+    expect(result.success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// ExecuteActionRequestSchema
+// ---------------------------------------------------------------------------
+
+describe('ExecuteActionRequestSchema', () => {
+  it('accepts an empty object (payload is optional)', () => {
+    expect(ExecuteActionRequestSchema.safeParse({}).success).toBe(true)
+  })
+
+  it('accepts a payload record with arbitrary string keys', () => {
+    const result = ExecuteActionRequestSchema.safeParse({
+      payload: { channel: 'email', count: 5, nested: { ok: true } }
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts an empty payload record', () => {
+    expect(ExecuteActionRequestSchema.safeParse({ payload: {} }).success).toBe(true)
+  })
+
+  it('rejects unknown top-level fields (strict mode)', () => {
+    const result = ExecuteActionRequestSchema.safeParse({ payload: {}, extra: 'bad' })
+    expect(result.success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// CreateDealNoteRequestSchema
+// ---------------------------------------------------------------------------
+
+describe('CreateDealNoteRequestSchema', () => {
+  it('accepts a valid body', () => {
+    expect(CreateDealNoteRequestSchema.safeParse({ body: 'Hello' }).success).toBe(true)
+  })
+
+  it('accepts a single character after trim', () => {
+    expect(CreateDealNoteRequestSchema.safeParse({ body: 'a' }).success).toBe(true)
+  })
+
+  it('trims whitespace and accepts content that remains non-empty', () => {
+    const result = CreateDealNoteRequestSchema.safeParse({ body: '  note  ' })
+    expect(result.success).toBe(true)
+    if (result.success) expect(result.data.body).toBe('note')
+  })
+
+  it('rejects a whitespace-only string (empty after trim)', () => {
+    expect(CreateDealNoteRequestSchema.safeParse({ body: '   ' }).success).toBe(false)
+  })
+
+  it('rejects an empty string', () => {
+    expect(CreateDealNoteRequestSchema.safeParse({ body: '' }).success).toBe(false)
+  })
+
+  it('accepts a body at the max length boundary (10000 chars)', () => {
+    expect(CreateDealNoteRequestSchema.safeParse({ body: 'a'.repeat(10000) }).success).toBe(true)
+  })
+
+  it('rejects a body exceeding the max length (10001 chars)', () => {
+    expect(CreateDealNoteRequestSchema.safeParse({ body: 'a'.repeat(10001) }).success).toBe(false)
+  })
+
+  it('rejects unknown top-level fields (strict mode)', () => {
+    expect(CreateDealNoteRequestSchema.safeParse({ body: 'note', extra: 'x' }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// CreateDealTaskRequestSchema
+// ---------------------------------------------------------------------------
+
+describe('CreateDealTaskRequestSchema', () => {
+  const valid = { title: 'Follow up call' }
+
+  it('accepts a minimal valid payload (title only)', () => {
+    expect(CreateDealTaskRequestSchema.safeParse(valid).success).toBe(true)
+  })
+
+  it('kind is optional and accepts all valid values', () => {
+    for (const kind of ['call', 'email', 'meeting', 'other'] as const) {
+      expect(CreateDealTaskRequestSchema.safeParse({ ...valid, kind }).success).toBe(true)
+    }
+  })
+
+  it('rejects an invalid kind value', () => {
+    expect(CreateDealTaskRequestSchema.safeParse({ ...valid, kind: 'sms' }).success).toBe(false)
+  })
+
+  it('accepts a valid ISO datetime for dueAt', () => {
+    expect(CreateDealTaskRequestSchema.safeParse({ ...valid, dueAt: ISO_TS }).success).toBe(true)
+  })
+
+  it('rejects an invalid datetime for dueAt', () => {
+    expect(CreateDealTaskRequestSchema.safeParse({ ...valid, dueAt: 'tomorrow' }).success).toBe(false)
+  })
+
+  it('accepts null for dueAt', () => {
+    expect(CreateDealTaskRequestSchema.safeParse({ ...valid, dueAt: null }).success).toBe(true)
+  })
+
+  it('accepts a valid UUID for assigneeUserId', () => {
+    expect(CreateDealTaskRequestSchema.safeParse({ ...valid, assigneeUserId: VALID_UUID }).success).toBe(true)
+  })
+
+  it('rejects a non-UUID for assigneeUserId', () => {
+    expect(CreateDealTaskRequestSchema.safeParse({ ...valid, assigneeUserId: 'not-a-uuid' }).success).toBe(false)
+  })
+
+  it('accepts null for assigneeUserId', () => {
+    expect(CreateDealTaskRequestSchema.safeParse({ ...valid, assigneeUserId: null }).success).toBe(true)
+  })
+
+  it('rejects an empty title', () => {
+    expect(CreateDealTaskRequestSchema.safeParse({ title: '' }).success).toBe(false)
+  })
+
+  it('rejects a title exceeding 255 chars', () => {
+    expect(CreateDealTaskRequestSchema.safeParse({ title: 'a'.repeat(256) }).success).toBe(false)
+  })
+
+  it('rejects unknown top-level fields (strict mode)', () => {
+    expect(CreateDealTaskRequestSchema.safeParse({ ...valid, bogus: true }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// ListDealsQuerySchema
+// ---------------------------------------------------------------------------
+
+describe('ListDealsQuerySchema', () => {
+  it('accepts an empty query (all defaults applied)', () => {
+    const result = ListDealsQuerySchema.safeParse({})
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.limit).toBe(50)
+      expect(result.data.offset).toBe(0)
+    }
+  })
+
+  it('coerces limit from string "50" to number 50', () => {
+    const result = ListDealsQuerySchema.safeParse({ limit: '50' })
+    expect(result.success).toBe(true)
+    if (result.success) expect(result.data.limit).toBe(50)
+  })
+
+  it('coerces offset from string "20" to number 20', () => {
+    const result = ListDealsQuerySchema.safeParse({ offset: '20' })
+    expect(result.success).toBe(true)
+    if (result.success) expect(result.data.offset).toBe(20)
+  })
+
+  it('rejects non-numeric string for limit', () => {
+    expect(ListDealsQuerySchema.safeParse({ limit: 'abc' }).success).toBe(false)
+  })
+
+  it('rejects non-numeric string for offset', () => {
+    expect(ListDealsQuerySchema.safeParse({ offset: 'abc' }).success).toBe(false)
+  })
+
+  it('rejects zero or negative limit (must be positive)', () => {
+    expect(ListDealsQuerySchema.safeParse({ limit: '0' }).success).toBe(false)
+    expect(ListDealsQuerySchema.safeParse({ limit: '-1' }).success).toBe(false)
+  })
+
+  it('rejects a negative offset', () => {
+    expect(ListDealsQuerySchema.safeParse({ offset: '-1' }).success).toBe(false)
+  })
+
+  it('accepts zero offset', () => {
+    expect(ListDealsQuerySchema.safeParse({ offset: '0' }).success).toBe(true)
+  })
+
+  it('accepts a valid stage filter with search and pagination', () => {
+    const result = ListDealsQuerySchema.safeParse({
+      stage: 'interested',
+      search: 'acme',
+      limit: '25',
+      offset: '10'
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.stage).toBe('interested')
+      expect(result.data.search).toBe('acme')
+      expect(result.data.limit).toBe(25)
+      expect(result.data.offset).toBe(10)
+    }
+  })
+
+  it('rejects an invalid stage value', () => {
+    expect(ListDealsQuerySchema.safeParse({ stage: 'pipeline' }).success).toBe(false)
+  })
+
+  it('rejects unknown query fields (strict mode)', () => {
+    expect(ListDealsQuerySchema.safeParse({ unknownParam: 'x' }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// UpdateContactRequestSchema
+// ---------------------------------------------------------------------------
+
+describe('UpdateContactRequestSchema', () => {
+  it('rejects an object with no fields provided', () => {
+    const result = UpdateContactRequestSchema.safeParse({})
+    expect(result.success).toBe(false)
+  })
+
+  it('accepts a single field: firstName', () => {
+    expect(UpdateContactRequestSchema.safeParse({ firstName: 'Alice' }).success).toBe(true)
+  })
+
+  it('accepts a single field: emailValid', () => {
+    for (const v of ['VALID', 'INVALID', 'RISKY', 'UNKNOWN'] as const) {
+      expect(UpdateContactRequestSchema.safeParse({ emailValid: v }).success).toBe(true)
+    }
+  })
+
+  it('rejects an invalid emailValid value', () => {
+    expect(UpdateContactRequestSchema.safeParse({ emailValid: 'maybe' }).success).toBe(false)
+  })
+
+  it('accepts a valid UUID for companyId', () => {
+    expect(UpdateContactRequestSchema.safeParse({ companyId: VALID_UUID }).success).toBe(true)
+  })
+
+  it('rejects a non-UUID for companyId', () => {
+    expect(UpdateContactRequestSchema.safeParse({ companyId: 'bad-id' }).success).toBe(false)
+  })
+
+  it('accepts a valid LinkedIn URL', () => {
+    expect(UpdateContactRequestSchema.safeParse({ linkedinUrl: 'https://linkedin.com/in/alice' }).success).toBe(true)
+  })
+
+  it('rejects a non-URL for linkedinUrl', () => {
+    expect(UpdateContactRequestSchema.safeParse({ linkedinUrl: 'not-a-url' }).success).toBe(false)
+  })
+
+  it('accepts multiple fields at once', () => {
+    expect(UpdateContactRequestSchema.safeParse({ firstName: 'Alice', lastName: 'Smith', title: 'CEO' }).success).toBe(
+      true
+    )
+  })
+
+  it('rejects unknown top-level fields (strict mode)', () => {
+    expect(UpdateContactRequestSchema.safeParse({ firstName: 'Alice', unknown: 'x' }).success).toBe(false)
+  })
+
+  it('rejects an empty string for firstName (min 1 after trim)', () => {
+    expect(UpdateContactRequestSchema.safeParse({ firstName: '' }).success).toBe(false)
+  })
+
+  it('rejects a firstName exceeding 255 chars', () => {
+    expect(UpdateContactRequestSchema.safeParse({ firstName: 'a'.repeat(256) }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Response schemas — smoke-level forward-compat checks
+// ---------------------------------------------------------------------------
+
+describe('DealDetailResponseSchema (forward-compat)', () => {
+  const baseDeal = {
+    id: VALID_UUID,
+    organization_id: VALID_UUID,
+    contact_id: null,
+    contact_email: 'test@example.com',
+    pipeline_key: 'default',
+    stage_key: null,
+    state_key: null,
+    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,
+    contact: null
+  }
+
+  it('accepts a deal with null contact', () => {
+    expect(DealDetailResponseSchema.safeParse(baseDeal).success).toBe(true)
+  })
+
+  it('accepts a deal with nested contact that has null company', () => {
+    const withContact = {
+      ...baseDeal,
+      contact: {
+        id: VALID_UUID,
+        first_name: 'Alice',
+        last_name: 'Smith',
+        email: 'alice@example.com',
+        title: null,
+        headline: null,
+        linkedin_url: null,
+        pipeline_status: null,
+        enrichment_data: null,
+        company: null
+      }
+    }
+    expect(DealDetailResponseSchema.safeParse(withContact).success).toBe(true)
+  })
+
+  it('accepts extra unknown fields at top level (not strict)', () => {
+    expect(DealDetailResponseSchema.safeParse({ ...baseDeal, futureField: 'value' }).success).toBe(true)
+  })
+})
+
+describe('DealListResponseSchema', () => {
+  it('accepts a valid paginated list response', () => {
+    const result = DealListResponseSchema.safeParse({
+      data: [],
+      total: 0,
+      limit: 50,
+      offset: 0
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects non-integer total', () => {
+    expect(DealListResponseSchema.safeParse({ data: [], total: 1.5, limit: 50, offset: 0 }).success).toBe(false)
+  })
+})
+
+describe('DealNoteResponseSchema', () => {
+  it('accepts a valid note response', () => {
+    const result = DealNoteResponseSchema.safeParse({
+      id: VALID_UUID,
+      dealId: VALID_UUID,
+      organizationId: VALID_UUID,
+      authorUserId: null,
+      body: 'A note',
+      createdAt: ISO_TS,
+      updatedAt: ISO_TS
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts extra fields (not strict)', () => {
+    const result = DealNoteResponseSchema.safeParse({
+      id: VALID_UUID,
+      dealId: VALID_UUID,
+      organizationId: VALID_UUID,
+      authorUserId: null,
+      body: 'A note',
+      createdAt: ISO_TS,
+      updatedAt: ISO_TS,
+      futureField: 'ignored'
+    })
+    expect(result.success).toBe(true)
+  })
+})
+
+describe('DealTaskResponseSchema', () => {
+  it('accepts a valid task response', () => {
+    const result = DealTaskResponseSchema.safeParse({
+      id: VALID_UUID,
+      organizationId: VALID_UUID,
+      dealId: VALID_UUID,
+      title: 'Call prospect',
+      description: null,
+      kind: 'call',
+      dueAt: null,
+      assigneeUserId: null,
+      completedAt: null,
+      completedByUserId: null,
+      createdAt: ISO_TS,
+      updatedAt: ISO_TS,
+      createdByUserId: null
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects an invalid kind in task response', () => {
+    const result = DealTaskResponseSchema.safeParse({
+      id: VALID_UUID,
+      organizationId: VALID_UUID,
+      dealId: VALID_UUID,
+      title: 'Call',
+      description: null,
+      kind: 'text_message',
+      dueAt: null,
+      assigneeUserId: null,
+      completedAt: null,
+      completedByUserId: null,
+      createdAt: ISO_TS,
+      updatedAt: ISO_TS,
+      createdByUserId: null
+    })
+    expect(result.success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// ListStatusSchema
+// ---------------------------------------------------------------------------
+
+describe('ListStatusSchema', () => {
+  it.each(['draft', 'enriching', 'launched', 'closing', 'archived'])('accepts "%s"', (status) => {
+    expect(ListStatusSchema.safeParse(status).success).toBe(true)
+  })
+
+  it('rejects unknown status', () => {
+    expect(ListStatusSchema.safeParse('active').success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// PipelineStageSchema
+// ---------------------------------------------------------------------------
+
+describe('PipelineStageSchema', () => {
+  it('accepts a key present in LEAD_GEN_STAGE_CATALOG', () => {
+    for (const key of Object.keys(LEAD_GEN_STAGE_CATALOG)) {
+      expect(PipelineStageSchema.safeParse({ key }).success).toBe(true)
+    }
+  })
+
+  it('rejects a key not in LEAD_GEN_STAGE_CATALOG', () => {
+    const result = PipelineStageSchema.safeParse({ key: 'not_a_real_stage' })
+    expect(result.success).toBe(false)
+    if (!result.success) {
+      expect(result.error.issues[0]?.message).toMatch(/LEAD_GEN_STAGE_CATALOG/)
+    }
+  })
+
+  it('accepts optional label, enabled, and order fields', () => {
+    expect(PipelineStageSchema.safeParse({ key: 'scraped', label: 'Scraped', enabled: true, order: 1 }).success).toBe(
+      true
+    )
+  })
+})
+
+// ---------------------------------------------------------------------------
+// ScrapingConfigSchema
+// ---------------------------------------------------------------------------
+
+describe('ScrapingConfigSchema', () => {
+  it('accepts an empty object (all fields optional)', () => {
+    expect(ScrapingConfigSchema.safeParse({}).success).toBe(true)
+  })
+
+  it('accepts a fully populated config', () => {
+    expect(
+      ScrapingConfigSchema.safeParse({
+        vertical: 'SaaS',
+        geography: 'USA',
+        size: '10-50',
+        apifyInput: { actorId: 'test' }
+      }).success
+    ).toBe(true)
+  })
+
+  it('rejects a vertical exceeding 255 chars', () => {
+    expect(ScrapingConfigSchema.safeParse({ vertical: 'a'.repeat(256) }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// IcpRubricSchema
+// ---------------------------------------------------------------------------
+
+describe('IcpRubricSchema', () => {
+  it('accepts an empty object', () => {
+    expect(IcpRubricSchema.safeParse({}).success).toBe(true)
+  })
+
+  it('accepts valid minRating boundary values 0 and 5', () => {
+    expect(IcpRubricSchema.safeParse({ minRating: 0 }).success).toBe(true)
+    expect(IcpRubricSchema.safeParse({ minRating: 5 }).success).toBe(true)
+  })
+
+  it('rejects minRating above 5', () => {
+    expect(IcpRubricSchema.safeParse({ minRating: 5.1 }).success).toBe(false)
+  })
+
+  it('rejects negative minRating', () => {
+    expect(IcpRubricSchema.safeParse({ minRating: -1 }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// CreateListRequestSchema
+// ---------------------------------------------------------------------------
+
+describe('CreateListRequestSchema', () => {
+  it('accepts a minimal valid payload (name only)', () => {
+    expect(CreateListRequestSchema.safeParse({ name: 'My List' }).success).toBe(true)
+  })
+
+  it('rejects an empty name', () => {
+    expect(CreateListRequestSchema.safeParse({ name: '' }).success).toBe(false)
+  })
+
+  it('rejects a name exceeding 255 chars', () => {
+    expect(CreateListRequestSchema.safeParse({ name: 'a'.repeat(256) }).success).toBe(false)
+  })
+
+  it('accepts an optional status from ListStatusSchema', () => {
+    expect(CreateListRequestSchema.safeParse({ name: 'X', status: 'draft' }).success).toBe(true)
+  })
+
+  it('rejects an invalid status', () => {
+    expect(CreateListRequestSchema.safeParse({ name: 'X', status: 'active' }).success).toBe(false)
+  })
+
+  it('rejects unknown fields (strict mode)', () => {
+    expect(CreateListRequestSchema.safeParse({ name: 'X', bogus: true }).success).toBe(false)
+  })
+
+  it('accepts nested scrapingConfig, icp, and pipelineConfig', () => {
+    expect(
+      CreateListRequestSchema.safeParse({
+        name: 'SaaS List',
+        scrapingConfig: { vertical: 'SaaS' },
+        icp: { minReviewCount: 5 },
+        pipelineConfig: { stages: [] }
+      }).success
+    ).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// UpdateListRequestSchema
+// ---------------------------------------------------------------------------
+
+describe('UpdateListRequestSchema', () => {
+  it('rejects an object with none of the required fields', () => {
+    const result = UpdateListRequestSchema.safeParse({})
+    expect(result.success).toBe(false)
+  })
+
+  it('accepts providing only name', () => {
+    expect(UpdateListRequestSchema.safeParse({ name: 'New Name' }).success).toBe(true)
+  })
+
+  it('accepts providing only description', () => {
+    expect(UpdateListRequestSchema.safeParse({ description: 'Desc' }).success).toBe(true)
+  })
+
+  it('accepts providing only batchIds', () => {
+    expect(UpdateListRequestSchema.safeParse({ batchIds: ['batch-1'] }).success).toBe(true)
+  })
+
+  it('rejects unknown fields (strict mode)', () => {
+    expect(UpdateListRequestSchema.safeParse({ name: 'X', extra: 'bad' }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// UpdateListStatusRequestSchema
+// ---------------------------------------------------------------------------
+
+describe('UpdateListStatusRequestSchema', () => {
+  it('accepts a valid status', () => {
+    expect(UpdateListStatusRequestSchema.safeParse({ status: 'launched' }).success).toBe(true)
+  })
+
+  it('rejects an invalid status', () => {
+    expect(UpdateListStatusRequestSchema.safeParse({ status: 'active' }).success).toBe(false)
+  })
+
+  it('rejects missing status field', () => {
+    expect(UpdateListStatusRequestSchema.safeParse({}).success).toBe(false)
+  })
+
+  it('rejects unknown fields (strict mode)', () => {
+    expect(UpdateListStatusRequestSchema.safeParse({ status: 'draft', extra: 'x' }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// UpdateListConfigRequestSchema
+// ---------------------------------------------------------------------------
+
+describe('UpdateListConfigRequestSchema', () => {
+  it('rejects an object with none of the config fields', () => {
+    expect(UpdateListConfigRequestSchema.safeParse({}).success).toBe(false)
+  })
+
+  it('accepts providing only scrapingConfig', () => {
+    expect(UpdateListConfigRequestSchema.safeParse({ scrapingConfig: { vertical: 'SaaS' } }).success).toBe(true)
+  })
+
+  it('accepts providing only icp', () => {
+    expect(UpdateListConfigRequestSchema.safeParse({ icp: { minReviewCount: 3 } }).success).toBe(true)
+  })
+
+  it('accepts providing only pipelineConfig', () => {
+    expect(UpdateListConfigRequestSchema.safeParse({ pipelineConfig: { stages: [] } }).success).toBe(true)
+  })
+
+  it('rejects unknown fields (strict mode)', () => {
+    expect(UpdateListConfigRequestSchema.safeParse({ scrapingConfig: {}, bogus: true }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// AddCompaniesToListRequestSchema / AddContactsToListRequestSchema
+// ---------------------------------------------------------------------------
+
+describe('AddCompaniesToListRequestSchema', () => {
+  it('accepts a valid list with one UUID', () => {
+    expect(AddCompaniesToListRequestSchema.safeParse({ companyIds: [VALID_UUID] }).success).toBe(true)
+  })
+
+  it('rejects an empty array (min 1)', () => {
+    expect(AddCompaniesToListRequestSchema.safeParse({ companyIds: [] }).success).toBe(false)
+  })
+
+  it('rejects more than 1000 IDs (max 1000)', () => {
+    const ids = Array.from({ length: 1001 }, (_, i) => `00000000-0000-0000-0000-${String(i).padStart(12, '0')}`)
+    expect(AddCompaniesToListRequestSchema.safeParse({ companyIds: ids }).success).toBe(false)
+  })
+
+  it('rejects non-UUID entries', () => {
+    expect(AddCompaniesToListRequestSchema.safeParse({ companyIds: ['not-a-uuid'] }).success).toBe(false)
+  })
+})
+
+describe('AddContactsToListRequestSchema', () => {
+  it('accepts a valid list with one UUID', () => {
+    expect(AddContactsToListRequestSchema.safeParse({ contactIds: [VALID_UUID] }).success).toBe(true)
+  })
+
+  it('rejects an empty array (min 1)', () => {
+    expect(AddContactsToListRequestSchema.safeParse({ contactIds: [] }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// ListCompaniesQuerySchema
+// ---------------------------------------------------------------------------
+
+describe('ListCompaniesQuerySchema', () => {
+  it('accepts an empty query (defaults applied)', () => {
+    const result = ListCompaniesQuerySchema.safeParse({})
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.limit).toBe(50)
+      expect(result.data.offset).toBe(0)
+    }
+  })
+
+  it('coerces limit from string "100" to number 100', () => {
+    const result = ListCompaniesQuerySchema.safeParse({ limit: '100' })
+    expect(result.success).toBe(true)
+    if (result.success) expect(result.data.limit).toBe(100)
+  })
+
+  it('rejects limit exceeding 5000', () => {
+    expect(ListCompaniesQuerySchema.safeParse({ limit: '5001' }).success).toBe(false)
+  })
+
+  it('rejects limit less than 1', () => {
+    expect(ListCompaniesQuerySchema.safeParse({ limit: '0' }).success).toBe(false)
+  })
+
+  it('accepts a valid status filter', () => {
+    expect(ListCompaniesQuerySchema.safeParse({ status: 'active' }).success).toBe(true)
+    expect(ListCompaniesQuerySchema.safeParse({ status: 'invalid' }).success).toBe(true)
+  })
+
+  it('rejects an invalid status', () => {
+    expect(ListCompaniesQuerySchema.safeParse({ status: 'pending' }).success).toBe(false)
+  })
+
+  it('accepts includeAll as boolean-like strings', () => {
+    const r1 = ListCompaniesQuerySchema.safeParse({ includeAll: 'true' })
+    expect(r1.success).toBe(true)
+    if (r1.success) expect(r1.data.includeAll).toBe(true)
+
+    const r2 = ListCompaniesQuerySchema.safeParse({ includeAll: 'false' })
+    expect(r2.success).toBe(true)
+    if (r2.success) expect(r2.data.includeAll).toBe(false)
+  })
+
+  it('rejects unknown fields (strict mode)', () => {
+    expect(ListCompaniesQuerySchema.safeParse({ unknownField: 'x' }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// ListContactsQuerySchema
+// ---------------------------------------------------------------------------
+
+describe('ListContactsQuerySchema', () => {
+  it('accepts an empty query with defaults', () => {
+    const result = ListContactsQuerySchema.safeParse({})
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.limit).toBe(5000)
+      expect(result.data.offset).toBe(0)
+    }
+  })
+
+  it('accepts openingLineIsNull as "true"', () => {
+    const result = ListContactsQuerySchema.safeParse({ openingLineIsNull: 'true' })
+    expect(result.success).toBe(true)
+    if (result.success) expect(result.data.openingLineIsNull).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// ListDealTasksDueQuerySchema
+// ---------------------------------------------------------------------------
+
+describe('ListDealTasksDueQuerySchema', () => {
+  it('accepts an empty query', () => {
+    expect(ListDealTasksDueQuerySchema.safeParse({}).success).toBe(true)
+  })
+
+  it.each(['overdue', 'today', 'today_and_overdue', 'upcoming'])('accepts window "%s"', (window) => {
+    expect(ListDealTasksDueQuerySchema.safeParse({ window }).success).toBe(true)
+  })
+
+  it('rejects an invalid window value', () => {
+    expect(ListDealTasksDueQuerySchema.safeParse({ window: 'this_week' }).success).toBe(false)
+  })
+
+  it('accepts a valid UUID for assigneeUserId', () => {
+    expect(ListDealTasksDueQuerySchema.safeParse({ assigneeUserId: VALID_UUID }).success).toBe(true)
+  })
+
+  it('rejects unknown fields (strict mode)', () => {
+    expect(ListDealTasksDueQuerySchema.safeParse({ window: 'today', extra: 'x' }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// CreateCompanyRequestSchema
+// ---------------------------------------------------------------------------
+
+describe('CreateCompanyRequestSchema', () => {
+  it('accepts a minimal payload (name only)', () => {
+    expect(CreateCompanyRequestSchema.safeParse({ name: 'Acme' }).success).toBe(true)
+  })
+
+  it('rejects an empty name', () => {
+    expect(CreateCompanyRequestSchema.safeParse({ name: '' }).success).toBe(false)
+  })
+
+  it('rejects a non-URL for linkedinUrl', () => {
+    expect(CreateCompanyRequestSchema.safeParse({ name: 'Acme', linkedinUrl: 'linkedin.com/co/acme' }).success).toBe(
+      false
+    )
+  })
+
+  it('accepts a valid URL for linkedinUrl', () => {
+    expect(
+      CreateCompanyRequestSchema.safeParse({ name: 'Acme', linkedinUrl: 'https://linkedin.com/company/acme' }).success
+    ).toBe(true)
+  })
+
+  it('rejects unknown fields (strict mode)', () => {
+    expect(CreateCompanyRequestSchema.safeParse({ name: 'Acme', bogus: true }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// UpdateCompanyRequestSchema
+// ---------------------------------------------------------------------------
+
+describe('UpdateCompanyRequestSchema', () => {
+  it('rejects an object with no fields (at-least-one refine)', () => {
+    expect(UpdateCompanyRequestSchema.safeParse({}).success).toBe(false)
+  })
+
+  it('accepts providing only name', () => {
+    expect(UpdateCompanyRequestSchema.safeParse({ name: 'Acme Corp' }).success).toBe(true)
+  })
+
+  it('accepts providing only status', () => {
+    expect(UpdateCompanyRequestSchema.safeParse({ status: 'active' }).success).toBe(true)
+    expect(UpdateCompanyRequestSchema.safeParse({ status: 'invalid' }).success).toBe(true)
+  })
+
+  it('accepts numEmployees of 0', () => {
+    expect(UpdateCompanyRequestSchema.safeParse({ numEmployees: 0 }).success).toBe(true)
+  })
+
+  it('rejects negative numEmployees', () => {
+    expect(UpdateCompanyRequestSchema.safeParse({ numEmployees: -1 }).success).toBe(false)
+  })
+
+  it('rejects unknown fields (strict mode)', () => {
+    expect(UpdateCompanyRequestSchema.safeParse({ name: 'X', extra: true }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// CreateContactRequestSchema
+// ---------------------------------------------------------------------------
+
+describe('CreateContactRequestSchema', () => {
+  it('accepts a minimal payload (email only)', () => {
+    expect(CreateContactRequestSchema.safeParse({ email: 'test@example.com' }).success).toBe(true)
+  })
+
+  it('rejects an invalid email', () => {
+    expect(CreateContactRequestSchema.safeParse({ email: 'not-an-email' }).success).toBe(false)
+  })
+
+  it('rejects an empty email', () => {
+    expect(CreateContactRequestSchema.safeParse({ email: '' }).success).toBe(false)
+  })
+
+  it('accepts an optional companyId as UUID', () => {
+    expect(CreateContactRequestSchema.safeParse({ email: 'a@b.com', companyId: VALID_UUID }).success).toBe(true)
+  })
+
+  it('rejects unknown fields (strict mode)', () => {
+    expect(CreateContactRequestSchema.safeParse({ email: 'a@b.com', unknown: 'x' }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// AcqEmailValidSchema / AcqContactStatusSchema / AcqCompanyStatusSchema
+// ---------------------------------------------------------------------------
+
+describe('AcqEmailValidSchema', () => {
+  it.each(['VALID', 'INVALID', 'RISKY', 'UNKNOWN'])('accepts "%s"', (v) => {
+    expect(AcqEmailValidSchema.safeParse(v).success).toBe(true)
+  })
+
+  it('rejects lowercase or unknown value', () => {
+    expect(AcqEmailValidSchema.safeParse('valid').success).toBe(false)
+    expect(AcqEmailValidSchema.safeParse('pending').success).toBe(false)
+  })
+})
+
+describe('AcqContactStatusSchema', () => {
+  it.each(['active', 'invalid'])('accepts "%s"', (s) => {
+    expect(AcqContactStatusSchema.safeParse(s).success).toBe(true)
+  })
+
+  it('rejects unknown status', () => {
+    expect(AcqContactStatusSchema.safeParse('deleted').success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// AcqArtifactOwnerKindSchema
+// ---------------------------------------------------------------------------
+
+describe('AcqArtifactOwnerKindSchema', () => {
+  it.each(['company', 'contact', 'deal', 'list', 'list_member'])('accepts "%s"', (kind) => {
+    expect(AcqArtifactOwnerKindSchema.safeParse(kind).success).toBe(true)
+  })
+
+  it('rejects unknown owner kind', () => {
+    expect(AcqArtifactOwnerKindSchema.safeParse('organization').success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// ListArtifactsQuerySchema
+// ---------------------------------------------------------------------------
+
+describe('ListArtifactsQuerySchema', () => {
+  it('accepts a valid query', () => {
+    expect(ListArtifactsQuerySchema.safeParse({ ownerKind: 'deal', ownerId: VALID_UUID }).success).toBe(true)
+  })
+
+  it('rejects an invalid ownerKind', () => {
+    expect(ListArtifactsQuerySchema.safeParse({ ownerKind: 'org', ownerId: VALID_UUID }).success).toBe(false)
+  })
+
+  it('rejects a non-UUID ownerId', () => {
+    expect(ListArtifactsQuerySchema.safeParse({ ownerKind: 'deal', ownerId: 'not-a-uuid' }).success).toBe(false)
+  })
+
+  it('rejects unknown fields (strict mode)', () => {
+    expect(ListArtifactsQuerySchema.safeParse({ ownerKind: 'deal', ownerId: VALID_UUID, extra: 'x' }).success).toBe(
+      false
+    )
+  })
+})
+
+// ---------------------------------------------------------------------------
+// CreateArtifactRequestSchema
+// ---------------------------------------------------------------------------
+
+describe('CreateArtifactRequestSchema', () => {
+  const valid = {
+    ownerKind: 'deal' as const,
+    ownerId: VALID_UUID,
+    kind: 'proposal',
+    content: { url: 'https://example.com' }
+  }
+
+  it('accepts a minimal valid payload', () => {
+    expect(CreateArtifactRequestSchema.safeParse(valid).success).toBe(true)
+  })
+
+  it('accepts an optional sourceExecutionId', () => {
+    expect(CreateArtifactRequestSchema.safeParse({ ...valid, sourceExecutionId: VALID_UUID }).success).toBe(true)
+  })
+
+  it('rejects a non-UUID sourceExecutionId', () => {
+    expect(CreateArtifactRequestSchema.safeParse({ ...valid, sourceExecutionId: 'not-a-uuid' }).success).toBe(false)
+  })
+
+  it('rejects an empty kind', () => {
+    expect(CreateArtifactRequestSchema.safeParse({ ...valid, kind: '' }).success).toBe(false)
+  })
+
+  it('rejects unknown fields (strict mode)', () => {
+    expect(CreateArtifactRequestSchema.safeParse({ ...valid, bogus: true }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// ListMembersQuerySchema
+// ---------------------------------------------------------------------------
+
+describe('ListMembersQuerySchema', () => {
+  it('accepts an empty query with defaults', () => {
+    const result = ListMembersQuerySchema.safeParse({})
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.limit).toBe(50)
+      expect(result.data.offset).toBe(0)
+    }
+  })
+
+  it('rejects limit exceeding 500', () => {
+    expect(ListMembersQuerySchema.safeParse({ limit: '501' }).success).toBe(false)
+  })
+
+  it('rejects limit less than 1', () => {
+    expect(ListMembersQuerySchema.safeParse({ limit: '0' }).success).toBe(false)
+  })
+
+  it('rejects unknown fields (strict mode)', () => {
+    expect(ListMembersQuerySchema.safeParse({ extra: 'x' }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// AcqListResponseSchema (forward-compat)
+// ---------------------------------------------------------------------------
+
+describe('AcqListResponseSchema (forward-compat)', () => {
+  const baseList = {
+    id: VALID_UUID,
+    organizationId: VALID_UUID,
+    name: 'Test List',
+    description: null,
+    type: 'standard',
+    batchIds: [],
+    instantlyCampaignId: null,
+    status: 'draft' as const,
+    metadata: {},
+    launchedAt: null,
+    completedAt: null,
+    createdAt: ISO_TS,
+    scrapingConfig: {},
+    icp: {},
+    pipelineConfig: {}
+  }
+
+  it('accepts a valid list response', () => {
+    expect(AcqListResponseSchema.safeParse(baseList).success).toBe(true)
+  })
+
+  it('accepts extra fields at top level (not strict)', () => {
+    expect(AcqListResponseSchema.safeParse({ ...baseList, futureField: 'extra' }).success).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// AcqContactResponseSchema (forward-compat)
+// ---------------------------------------------------------------------------
+
+describe('AcqContactResponseSchema (forward-compat)', () => {
+  const baseContact = {
+    id: VALID_UUID,
+    organizationId: VALID_UUID,
+    companyId: null,
+    email: 'alice@example.com',
+    emailValid: null,
+    firstName: null,
+    lastName: null,
+    linkedinUrl: null,
+    title: null,
+    headline: null,
+    filterReason: null,
+    openingLine: null,
+    source: null,
+    sourceId: null,
+    pipelineStatus: null,
+    enrichmentData: null,
+    attioPersonId: null,
+    batchId: null,
+    status: 'active' as const,
+    createdAt: ISO_TS,
+    updatedAt: ISO_TS
+  }
+
+  it('accepts a valid contact response', () => {
+    expect(AcqContactResponseSchema.safeParse(baseContact).success).toBe(true)
+  })
+
+  it('accepts extra fields (not strict)', () => {
+    expect(AcqContactResponseSchema.safeParse({ ...baseContact, newField: 'x' }).success).toBe(true)
+  })
+
+  it('rejects an invalid emailValid value', () => {
+    expect(AcqContactResponseSchema.safeParse({ ...baseContact, emailValid: 'BAD' }).success).toBe(false)
+  })
+})