@elevasis/core 0.5.0 → 0.7.0

package/src/organization-model/__tests__/domains/resource-mappings.test.ts

@@ -0,0 +1,362 @@
+import { describe, expect, it } from 'vitest'
+import { ResourceMappingSchema, TechStackEntrySchema } from '../../domains/shared'
+import { resolveOrganizationModel } from '../../resolve'
+
+// ---------------------------------------------------------------------------
+// Minimal valid resource mapping fixture (no techStack) for reuse.
+// ---------------------------------------------------------------------------
+
+const MINIMAL_MAPPING = {
+  id: 'rm-hubspot-sync',
+  label: 'HubSpot Sync',
+  resourceId: 'hubspot-sync-workflow',
+  resourceType: 'workflow' as const,
+  featureIds: [],
+  entityIds: [],
+  surfaceIds: [],
+  capabilityIds: []
+}
+
+// ---------------------------------------------------------------------------
+// Group 1: TechStackEntrySchema — positive parse
+// ---------------------------------------------------------------------------
+
+describe('TechStackEntrySchema — positive parse', () => {
+  it('accepts a fully-populated tech stack entry', () => {
+    const result = TechStackEntrySchema.safeParse({
+      platform: 'HubSpot',
+      purpose: 'Primary CRM and contact management',
+      credentialStatus: 'configured',
+      isSystemOfRecord: true
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.platform).toBe('HubSpot')
+      expect(result.data.credentialStatus).toBe('configured')
+      expect(result.data.isSystemOfRecord).toBe(true)
+    }
+  })
+
+  it('isSystemOfRecord defaults to false when omitted', () => {
+    const result = TechStackEntrySchema.safeParse({
+      platform: 'Stripe',
+      purpose: 'Payment processing',
+      credentialStatus: 'pending'
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.isSystemOfRecord).toBe(false)
+    }
+  })
+
+  it('accepts all four credentialStatus enum values', () => {
+    const statuses = ['configured', 'pending', 'expired', 'missing'] as const
+    for (const status of statuses) {
+      const result = TechStackEntrySchema.safeParse({
+        platform: 'SomePlatform',
+        purpose: 'Some purpose',
+        credentialStatus: status
+      })
+      expect(result.success).toBe(true)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 2: TechStackEntrySchema — negative parse
+// ---------------------------------------------------------------------------
+
+describe('TechStackEntrySchema — negative parse', () => {
+  it('rejects invalid credentialStatus enum value', () => {
+    const result = TechStackEntrySchema.safeParse({
+      platform: 'HubSpot',
+      purpose: 'CRM',
+      credentialStatus: 'active'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects missing platform', () => {
+    const result = TechStackEntrySchema.safeParse({
+      purpose: 'CRM',
+      credentialStatus: 'configured'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects empty string platform', () => {
+    const result = TechStackEntrySchema.safeParse({
+      platform: '',
+      purpose: 'CRM',
+      credentialStatus: 'configured'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects missing purpose', () => {
+    const result = TechStackEntrySchema.safeParse({
+      platform: 'HubSpot',
+      credentialStatus: 'configured'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects empty string purpose', () => {
+    const result = TechStackEntrySchema.safeParse({
+      platform: 'HubSpot',
+      purpose: '',
+      credentialStatus: 'configured'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects missing credentialStatus', () => {
+    const result = TechStackEntrySchema.safeParse({
+      platform: 'HubSpot',
+      purpose: 'CRM'
+    })
+    expect(result.success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 3: ResourceMappingSchema — backward compatibility (no techStack)
+// ---------------------------------------------------------------------------
+
+describe('ResourceMappingSchema — backward compatibility without techStack', () => {
+  it('parses a mapping with no techStack key (legacy shape)', () => {
+    const result = ResourceMappingSchema.safeParse(MINIMAL_MAPPING)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.techStack).toBeUndefined()
+    }
+  })
+
+  it('parses a mapping with techStack explicitly set to undefined', () => {
+    const result = ResourceMappingSchema.safeParse({ ...MINIMAL_MAPPING, techStack: undefined })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.techStack).toBeUndefined()
+    }
+  })
+
+  it('all existing reference ID fields still default to empty arrays', () => {
+    const result = ResourceMappingSchema.safeParse({
+      id: 'rm-bare',
+      label: 'Bare mapping',
+      resourceId: 'bare-workflow',
+      resourceType: 'workflow'
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.featureIds).toEqual([])
+      expect(result.data.entityIds).toEqual([])
+      expect(result.data.surfaceIds).toEqual([])
+      expect(result.data.capabilityIds).toEqual([])
+      expect(result.data.techStack).toBeUndefined()
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 4: ResourceMappingSchema — with techStack
+// ---------------------------------------------------------------------------
+
+describe('ResourceMappingSchema — with techStack', () => {
+  it('parses a mapping with a full techStack object', () => {
+    const result = ResourceMappingSchema.safeParse({
+      ...MINIMAL_MAPPING,
+      techStack: {
+        platform: 'HubSpot',
+        purpose: 'Contact and deal management',
+        credentialStatus: 'configured',
+        isSystemOfRecord: true
+      }
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.techStack).toBeDefined()
+      expect(result.data.techStack?.platform).toBe('HubSpot')
+      expect(result.data.techStack?.credentialStatus).toBe('configured')
+      expect(result.data.techStack?.isSystemOfRecord).toBe(true)
+    }
+  })
+
+  it('isSystemOfRecord defaults to false inside techStack when omitted', () => {
+    const result = ResourceMappingSchema.safeParse({
+      ...MINIMAL_MAPPING,
+      techStack: {
+        platform: 'Notion',
+        purpose: 'Internal knowledge base',
+        credentialStatus: 'pending'
+      }
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.techStack?.isSystemOfRecord).toBe(false)
+    }
+  })
+
+  it('rejects a mapping with an invalid credentialStatus in techStack', () => {
+    const result = ResourceMappingSchema.safeParse({
+      ...MINIMAL_MAPPING,
+      techStack: {
+        platform: 'Stripe',
+        purpose: 'Billing',
+        credentialStatus: 'broken'
+      }
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects a mapping with techStack missing platform', () => {
+    const result = ResourceMappingSchema.safeParse({
+      ...MINIMAL_MAPPING,
+      techStack: {
+        purpose: 'Something',
+        credentialStatus: 'configured'
+      }
+    })
+    expect(result.success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 5: Multiple mappings with mixed techStack presence
+// ---------------------------------------------------------------------------
+
+describe('ResourceMappingSchema — mixed techStack presence across entries', () => {
+  it('resolves a model with multiple mappings — some with techStack, some without', () => {
+    const withStack = {
+      ...MINIMAL_MAPPING,
+      id: 'rm-with-stack',
+      resourceId: 'workflow-with-stack',
+      techStack: {
+        platform: 'Intercom',
+        purpose: 'Customer support',
+        credentialStatus: 'expired' as const
+      }
+    }
+    const withoutStack = {
+      id: 'rm-without-stack',
+      label: 'Plain mapping',
+      resourceId: 'plain-workflow',
+      resourceType: 'integration' as const,
+      featureIds: [],
+      entityIds: [],
+      surfaceIds: [],
+      capabilityIds: []
+    }
+
+    const withResult = ResourceMappingSchema.safeParse(withStack)
+    const withoutResult = ResourceMappingSchema.safeParse(withoutStack)
+
+    expect(withResult.success).toBe(true)
+    expect(withoutResult.success).toBe(true)
+
+    if (withResult.success) {
+      expect(withResult.data.techStack?.credentialStatus).toBe('expired')
+    }
+    if (withoutResult.success) {
+      expect(withoutResult.data.techStack).toBeUndefined()
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 6: Integration via resolveOrganizationModel
+// ---------------------------------------------------------------------------
+
+describe('resolveOrganizationModel — resourceMappings with techStack', () => {
+  it('resolves a model with no resourceMappings (default empty array)', () => {
+    const model = resolveOrganizationModel({})
+    expect(model.resourceMappings).toEqual([])
+  })
+
+  it('resolves a model with a resourceMapping that has no techStack', () => {
+    const model = resolveOrganizationModel({
+      resourceMappings: [
+        {
+          id: 'rm-legacy',
+          label: 'Legacy mapping',
+          resourceId: 'legacy-workflow',
+          resourceType: 'workflow',
+          featureIds: [],
+          entityIds: [],
+          surfaceIds: [],
+          capabilityIds: []
+        }
+      ]
+    })
+    expect(model.resourceMappings).toHaveLength(1)
+    expect(model.resourceMappings[0].techStack).toBeUndefined()
+  })
+
+  it('resolves a model with a resourceMapping that has techStack', () => {
+    const model = resolveOrganizationModel({
+      resourceMappings: [
+        {
+          id: 'rm-crm-sync',
+          label: 'CRM Sync',
+          resourceId: 'crm-sync-workflow',
+          resourceType: 'workflow',
+          featureIds: [],
+          entityIds: [],
+          surfaceIds: [],
+          capabilityIds: [],
+          techStack: {
+            platform: 'Salesforce',
+            purpose: 'Enterprise CRM integration',
+            credentialStatus: 'configured',
+            isSystemOfRecord: true
+          }
+        }
+      ]
+    })
+    expect(model.resourceMappings).toHaveLength(1)
+    const mapping = model.resourceMappings[0]
+    expect(mapping.techStack).toBeDefined()
+    expect(mapping.techStack?.platform).toBe('Salesforce')
+    expect(mapping.techStack?.isSystemOfRecord).toBe(true)
+  })
+
+  it('resolves multiple mappings with mixed techStack presence', () => {
+    const model = resolveOrganizationModel({
+      resourceMappings: [
+        {
+          id: 'rm-a',
+          label: 'Mapping A',
+          resourceId: 'workflow-a',
+          resourceType: 'workflow',
+          featureIds: [],
+          entityIds: [],
+          surfaceIds: [],
+          capabilityIds: [],
+          techStack: {
+            platform: 'HubSpot',
+            purpose: 'Contacts',
+            credentialStatus: 'pending'
+          }
+        },
+        {
+          id: 'rm-b',
+          label: 'Mapping B',
+          resourceId: 'workflow-b',
+          resourceType: 'agent',
+          featureIds: [],
+          entityIds: [],
+          surfaceIds: [],
+          capabilityIds: []
+        }
+      ]
+    })
+    expect(model.resourceMappings).toHaveLength(2)
+    expect(model.resourceMappings[0].techStack?.platform).toBe('HubSpot')
+    expect(model.resourceMappings[0].techStack?.isSystemOfRecord).toBe(false)
+    expect(model.resourceMappings[1].techStack).toBeUndefined()
+  })
+
+  it('resolved model still validates without errors when resourceMappings omitted', () => {
+    expect(() => resolveOrganizationModel({})).not.toThrow()
+  })
+})

package/src/organization-model/__tests__/domains/roles.test.ts

@@ -0,0 +1,347 @@
+import { describe, expect, it } from 'vitest'
+import { RoleSchema, RolesDomainSchema, DEFAULT_ORGANIZATION_MODEL_ROLES } from '../../domains/roles'
+import { resolveOrganizationModel } from '../../resolve'
+
+// ---------------------------------------------------------------------------
+// Group 1: RoleSchema — positive parse
+// ---------------------------------------------------------------------------
+
+describe('RoleSchema — positive parse', () => {
+  it('accepts a fully-populated role', () => {
+    const result = RoleSchema.safeParse({
+      id: 'role-ceo',
+      title: 'CEO',
+      responsibilities: ['Set company direction', 'Hire and develop leadership team'],
+      reportsToId: undefined,
+      heldBy: 'Alice Johnson'
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts a minimal role — only id and title required', () => {
+    const result = RoleSchema.safeParse({ id: 'role-minimal', title: 'Head of Sales' })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.id).toBe('role-minimal')
+      expect(result.data.title).toBe('Head of Sales')
+      expect(result.data.responsibilities).toEqual([])
+      expect(result.data.reportsToId).toBeUndefined()
+      expect(result.data.heldBy).toBeUndefined()
+    }
+  })
+
+  it('accepts a role with heldBy set to a name', () => {
+    const result = RoleSchema.safeParse({
+      id: 'role-cfo',
+      title: 'CFO',
+      heldBy: 'Bob Smith'
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.heldBy).toBe('Bob Smith')
+    }
+  })
+
+  it('accepts a role with heldBy set to an email address', () => {
+    const result = RoleSchema.safeParse({
+      id: 'role-cto',
+      title: 'CTO',
+      heldBy: 'carol@example.com'
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.heldBy).toBe('carol@example.com')
+    }
+  })
+
+  it('accepts a role with a non-empty responsibilities list', () => {
+    const result = RoleSchema.safeParse({
+      id: 'role-ops',
+      title: 'Operations Manager',
+      responsibilities: ['Oversee daily operations', 'Manage vendor relationships', 'Report KPIs']
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.responsibilities).toHaveLength(3)
+    }
+  })
+
+  it('trims whitespace from id and title', () => {
+    const result = RoleSchema.safeParse({
+      id: '  role-trim  ',
+      title: '  Trimmed Title  '
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.id).toBe('role-trim')
+      expect(result.data.title).toBe('Trimmed Title')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 2: RoleSchema — default values
+// ---------------------------------------------------------------------------
+
+describe('RoleSchema — default values', () => {
+  it('responsibilities defaults to empty array when omitted', () => {
+    const result = RoleSchema.safeParse({ id: 'role-defaults', title: 'Engineer' })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.responsibilities).toEqual([])
+    }
+  })
+
+  it('reportsToId is optional — absent by default', () => {
+    const result = RoleSchema.safeParse({ id: 'role-defaults', title: 'Engineer' })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.reportsToId).toBeUndefined()
+    }
+  })
+
+  it('heldBy is optional — absent by default', () => {
+    const result = RoleSchema.safeParse({ id: 'role-defaults', title: 'Engineer' })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.heldBy).toBeUndefined()
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 3: RoleSchema — negative parse
+// ---------------------------------------------------------------------------
+
+describe('RoleSchema — negative parse', () => {
+  it('rejects missing id', () => {
+    const result = RoleSchema.safeParse({ title: 'No ID Role' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects empty string id', () => {
+    const result = RoleSchema.safeParse({ id: '', title: 'Empty ID' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects whitespace-only id (trims to empty string)', () => {
+    const result = RoleSchema.safeParse({ id: '   ', title: 'Whitespace ID' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects missing title', () => {
+    const result = RoleSchema.safeParse({ id: 'role-no-title' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects empty string title', () => {
+    const result = RoleSchema.safeParse({ id: 'role-empty-title', title: '' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects whitespace-only title (trims to empty string)', () => {
+    const result = RoleSchema.safeParse({ id: 'role-whitespace-title', title: '   ' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects responsibilities as a non-array value', () => {
+    const result = RoleSchema.safeParse({
+      id: 'role-bad-resp',
+      title: 'Bad Role',
+      responsibilities: 'single string'
+    })
+    expect(result.success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 4: Plain-language field names assertion
+// No EOS jargon — parsed role must have `title`, `responsibilities`,
+// `reportsToId`, `heldBy` as literal property names; must NOT have
+// `seatTitle`, `accountabilities`, `seat`, or `seats`.
+// ---------------------------------------------------------------------------
+
+describe('RoleSchema — plain-language field names (no EOS jargon)', () => {
+  it('parsed role has the plain-language keys title / responsibilities / reportsToId / heldBy', () => {
+    const result = RoleSchema.safeParse({
+      id: 'role-plain',
+      title: 'Product Lead',
+      responsibilities: ['Own roadmap'],
+      reportsToId: 'role-ceo',
+      heldBy: 'Dave'
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      const keys = Object.keys(result.data)
+      expect(keys).toContain('title')
+      expect(keys).toContain('responsibilities')
+      expect(keys).toContain('reportsToId')
+      expect(keys).toContain('heldBy')
+      // Ensure no EOS jargon field names survive
+      expect(keys).not.toContain('seatTitle')
+      expect(keys).not.toContain('accountabilities')
+      expect(keys).not.toContain('seat')
+      expect(keys).not.toContain('seats')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 5: RolesDomainSchema — structural
+// ---------------------------------------------------------------------------
+
+describe('RolesDomainSchema — structural', () => {
+  it('accepts an empty roles array', () => {
+    const result = RolesDomainSchema.safeParse({ roles: [] })
+    expect(result.success).toBe(true)
+  })
+
+  it('defaults roles to empty array when key is omitted', () => {
+    const result = RolesDomainSchema.safeParse({})
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.roles).toEqual([])
+    }
+  })
+
+  it('accepts multiple valid roles', () => {
+    const result = RolesDomainSchema.safeParse({
+      roles: [
+        { id: 'role-a', title: 'CEO' },
+        { id: 'role-b', title: 'COO', reportsToId: 'role-a' }
+      ]
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.roles).toHaveLength(2)
+    }
+  })
+
+  it('rejects roles as a non-array value', () => {
+    const result = RolesDomainSchema.safeParse({ roles: 'not an array' })
+    expect(result.success).toBe(false)
+  })
+
+  it('DEFAULT_ORGANIZATION_MODEL_ROLES constant matches schema parse of empty object', () => {
+    const result = RolesDomainSchema.safeParse({})
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data).toEqual(DEFAULT_ORGANIZATION_MODEL_ROLES)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 6: Cross-ref validation — reportsToId via resolveOrganizationModel
+// ---------------------------------------------------------------------------
+
+describe('resolveOrganizationModel — roles cross-ref (reportsToId)', () => {
+  it('passes when reportsToId references a declared role id', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        roles: {
+          roles: [
+            { id: 'role-ceo', title: 'CEO' },
+            { id: 'role-coo', title: 'COO', reportsToId: 'role-ceo' }
+          ]
+        }
+      })
+    ).not.toThrow()
+  })
+
+  it('throws when reportsToId references a non-existent role', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        roles: {
+          roles: [{ id: 'role-orphan', title: 'Orphan Role', reportsToId: 'nonexistent-role' }]
+        }
+      })
+    ).toThrow()
+  })
+
+  it('throws with a message referencing the unknown reportsToId', () => {
+    let errorMessage = ''
+    try {
+      resolveOrganizationModel({
+        roles: {
+          roles: [{ id: 'role-bad-ref', title: 'Bad Ref Role', reportsToId: 'ghost-role' }]
+        }
+      })
+    } catch (e) {
+      errorMessage = String(e)
+    }
+    expect(errorMessage).toContain('ghost-role')
+  })
+
+  it('passes when reportsToId is absent (top-level role, no reporting line)', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        roles: {
+          roles: [{ id: 'role-top', title: 'Top Level Role' }]
+        }
+      })
+    ).not.toThrow()
+  })
+
+  it('passes when multiple roles form a valid reporting chain', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        roles: {
+          roles: [
+            { id: 'role-ceo', title: 'CEO' },
+            { id: 'role-vp', title: 'VP of Engineering', reportsToId: 'role-ceo' },
+            { id: 'role-eng', title: 'Senior Engineer', reportsToId: 'role-vp' }
+          ]
+        }
+      })
+    ).not.toThrow()
+  })
+
+  it('passes when roles array is empty (no refs to validate)', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        roles: { roles: [] }
+      })
+    ).not.toThrow()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 7: Integration — resolveOrganizationModel general
+// ---------------------------------------------------------------------------
+
+describe('resolveOrganizationModel — roles domain integration', () => {
+  it('merges partial roles override and preserves empty roles default', () => {
+    const model = resolveOrganizationModel({ roles: { roles: [] } })
+    expect(model.roles.roles).toEqual([])
+  })
+
+  it('omitting roles key entirely resolves to default empty roles', () => {
+    const model = resolveOrganizationModel({})
+    expect(model.roles).toBeDefined()
+    expect(model.roles.roles).toEqual([])
+  })
+
+  it('does not bleed roles changes into other top-level domains', () => {
+    const model = resolveOrganizationModel({
+      roles: {
+        roles: [{ id: 'role-ceo', title: 'CEO' }]
+      }
+    })
+    expect(model.identity).toBeDefined()
+    expect(model.customers).toBeDefined()
+    expect(model.offerings).toBeDefined()
+    expect(model.features).toBeDefined()
+    expect(model.navigation).toBeDefined()
+  })
+
+  it('resolved model includes roles domain alongside other new domains', () => {
+    const model = resolveOrganizationModel({
+      customers: { segments: [{ id: 'seg-a', name: 'Segment A' }] },
+      roles: { roles: [{ id: 'role-ceo', title: 'CEO', heldBy: 'Alice' }] }
+    })
+    expect(model.customers.segments).toHaveLength(1)
+    expect(model.roles.roles).toHaveLength(1)
+    expect(model.roles.roles[0].heldBy).toBe('Alice')
+  })
+})