@elevasis/core 0.23.0 → 0.24.1

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

@@ -1,209 +1,209 @@
-import { describe, expect, it, vi } from 'vitest'
-import {
-  DEFAULT_ORGANIZATION_MODEL_SYSTEMS,
-  SystemEntrySchema,
-  SystemKindSchema,
-  SystemStatusSchema,
-  SystemsDomainSchema
-} from '../../domains/systems'
-import { resolveOrganizationModel } from '../../resolve'
-
-const VALID_SYSTEM = {
-  id: 'sys.lead-gen',
-  order: 10,
-  title: 'Lead Generation Pipeline',
-  description: 'Coordinates prospecting, enrichment, qualification, and outreach preparation.',
-  kind: 'operational' as const
-}
-
-describe('SystemEntrySchema - positive parse', () => {
-  it('accepts a minimal tenant-defined system', () => {
-    const result = SystemEntrySchema.safeParse(VALID_SYSTEM)
-
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.governedByKnowledge).toEqual([])
-      expect(result.data.drivesGoals).toEqual([])
-    }
-  })
-
-  it('accepts all optional governance references when present', () => {
-    const result = SystemEntrySchema.safeParse({
-      ...VALID_SYSTEM,
-      responsibleRoleId: 'role.sales-ops',
-      governedByKnowledge: ['knowledge.lead-gen-playbook'],
-      drivesGoals: ['goal.pipeline-coverage']
-    })
-
-    expect(result.success).toBe(true)
-  })
-
-  it('trims id, title, and description', () => {
-    const result = SystemEntrySchema.safeParse({
-      ...VALID_SYSTEM,
-      id: '  sys.crm  ',
-      title: '  CRM  ',
-      description: '  Owns relationship and deal pipeline operations.  '
-    })
-
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.id).toBe('sys.crm')
-      expect(result.data.title).toBe('CRM')
-      expect(result.data.description).toBe('Owns relationship and deal pipeline operations.')
-    }
-  })
-
-  it('accepts deprecated status and maps it to lifecycle for one-cycle compatibility', () => {
-    const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
-
-    const result = SystemEntrySchema.safeParse({
-      ...VALID_SYSTEM,
-      status: 'deprecated'
-    })
-
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.status).toBe('deprecated')
-      expect(result.data.lifecycle).toBe('deprecated')
-    }
-    expect(warn).toHaveBeenCalledWith('[organization-model] System.status is deprecated; use System.lifecycle instead.')
-
-    warn.mockRestore()
-  })
-})
-
-describe('SystemEntrySchema - negative parse', () => {
-  it('rejects missing required fields', () => {
-    expect(SystemEntrySchema.safeParse({ id: 'sys.missing' }).success).toBe(false)
-  })
-
-  it('rejects an unknown system kind', () => {
-    expect(SystemEntrySchema.safeParse({ ...VALID_SYSTEM, kind: 'sales' }).success).toBe(false)
-  })
-
-  it('rejects an unknown deprecated system status', () => {
-    expect(SystemEntrySchema.safeParse({ ...VALID_SYSTEM, status: 'paused' }).success).toBe(false)
-  })
-
-  it('rejects IDs that do not match the OM model-id format', () => {
-    expect(SystemEntrySchema.safeParse({ ...VALID_SYSTEM, id: 'Sys Lead Gen' }).success).toBe(false)
-  })
-})
-
-describe('SystemsDomainSchema', () => {
-  it('accepts an empty systems record', () => {
-    expect(SystemsDomainSchema.safeParse({}).success).toBe(true)
-  })
-
-  it('defaults systems to an empty record when omitted', () => {
-    const result = SystemsDomainSchema.safeParse({})
-
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data).toEqual(DEFAULT_ORGANIZATION_MODEL_SYSTEMS)
-    }
-  })
-})
-
-describe('SystemKindSchema', () => {
-  it.each(['product', 'operational', 'platform', 'diagnostic'] as const)('accepts kind "%s"', (kind) => {
-    expect(SystemKindSchema.safeParse(kind).success).toBe(true)
-  })
-})
-
-describe('SystemStatusSchema', () => {
-  it.each(['active', 'deprecated', 'archived'] as const)('accepts deprecated status "%s"', (status) => {
-    expect(SystemStatusSchema.safeParse(status).success).toBe(true)
-  })
-})
-
-describe('resolveOrganizationModel - systems domain integration', () => {
-  it('omitting systems keeps default system entries', () => {
-    const model = resolveOrganizationModel({})
-
-    expect(Object.keys(model.systems).length).toBeGreaterThan(Object.keys(DEFAULT_ORGANIZATION_MODEL_SYSTEMS).length)
-    expect(model.systems['sales.crm']?.path).toBe('/crm')
-  })
-
-  it('accepts valid responsible role, knowledge, and goal references', () => {
-    expect(() =>
-      resolveOrganizationModel({
-        roles: {
-          'role.sales-ops': { id: 'role.sales-ops', order: 10, title: 'Sales Ops' }
-        },
-        goals: {
-          'goal.pipeline-coverage': {
-            id: 'goal.pipeline-coverage',
-            order: 10,
-            description: 'Improve sales pipeline coverage',
-            periodStart: '2026-01-01',
-            periodEnd: '2026-12-31'
-          }
-        },
-        knowledge: {
-          'knowledge.lead-gen-playbook': {
-            id: 'knowledge.lead-gen-playbook',
-            kind: 'playbook',
-            title: 'Lead Gen Playbook',
-            summary: 'How lead generation is governed.',
-            body: '## Lead Gen',
-            updatedAt: '2026-05-08'
-          }
-        },
-        systems: {
-          'sys.lead-gen': {
-            ...VALID_SYSTEM,
-            responsibleRoleId: 'role.sales-ops',
-            governedByKnowledge: ['knowledge.lead-gen-playbook'],
-            drivesGoals: ['goal.pipeline-coverage']
-          }
-        }
-      })
-    ).not.toThrow()
-  })
-
-  it('throws when system IDs are duplicated', () => {
-    expect(() =>
-      resolveOrganizationModel({
-        systems: {
-          'sys.lead-gen': VALID_SYSTEM,
-          'sys.lead-gen-dup': {
-            ...VALID_SYSTEM,
-            id: 'sys.lead-gen'
-          }
-        }
-      })
-    ).toThrow()
-  })
-
-  it('throws when responsibleRoleId references an unknown role', () => {
-    expect(() =>
-      resolveOrganizationModel({
-        systems: {
-          'sys.lead-gen': { ...VALID_SYSTEM, responsibleRoleId: 'role.missing' }
-        }
-      })
-    ).toThrow(/unknown responsibleRoleId \\"role\.missing\\"/)
-  })
-
-  it('throws when governedByKnowledge references an unknown knowledge node', () => {
-    expect(() =>
-      resolveOrganizationModel({
-        systems: {
-          'sys.lead-gen': { ...VALID_SYSTEM, governedByKnowledge: ['knowledge.missing'] }
-        }
-      })
-    ).toThrow(/unknown knowledge node \\"knowledge\.missing\\"/)
-  })
-
-  it('throws when drivesGoals references an unknown goal', () => {
-    expect(() =>
-      resolveOrganizationModel({
-        systems: {
-          'sys.lead-gen': { ...VALID_SYSTEM, drivesGoals: ['goal.missing'] }
-        }
-      })
-    ).toThrow(/unknown goal \\"goal\.missing\\"/)
-  })
-})
+import { describe, expect, it, vi } from 'vitest'
+import {
+  DEFAULT_ORGANIZATION_MODEL_SYSTEMS,
+  SystemEntrySchema,
+  SystemKindSchema,
+  SystemStatusSchema,
+  SystemsDomainSchema
+} from '../../domains/systems'
+import { resolveOrganizationModel } from '../../resolve'
+
+const VALID_SYSTEM = {
+  id: 'sys.lead-gen',
+  order: 10,
+  title: 'Lead Generation Pipeline',
+  description: 'Coordinates prospecting, enrichment, qualification, and outreach preparation.',
+  kind: 'operational' as const
+}
+
+describe('SystemEntrySchema - positive parse', () => {
+  it('accepts a minimal tenant-defined system', () => {
+    const result = SystemEntrySchema.safeParse(VALID_SYSTEM)
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.governedByKnowledge).toEqual([])
+      expect(result.data.drivesGoals).toEqual([])
+    }
+  })
+
+  it('accepts all optional governance references when present', () => {
+    const result = SystemEntrySchema.safeParse({
+      ...VALID_SYSTEM,
+      responsibleRoleId: 'role.sales-ops',
+      governedByKnowledge: ['knowledge.lead-gen-playbook'],
+      drivesGoals: ['goal.pipeline-coverage']
+    })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('trims id, title, and description', () => {
+    const result = SystemEntrySchema.safeParse({
+      ...VALID_SYSTEM,
+      id: '  sys.crm  ',
+      title: '  CRM  ',
+      description: '  Owns relationship and deal pipeline operations.  '
+    })
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.id).toBe('sys.crm')
+      expect(result.data.title).toBe('CRM')
+      expect(result.data.description).toBe('Owns relationship and deal pipeline operations.')
+    }
+  })
+
+  it('accepts deprecated status and maps it to lifecycle for one-cycle compatibility', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
+
+    const result = SystemEntrySchema.safeParse({
+      ...VALID_SYSTEM,
+      status: 'deprecated'
+    })
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.status).toBe('deprecated')
+      expect(result.data.lifecycle).toBe('deprecated')
+    }
+    expect(warn).toHaveBeenCalledWith('[organization-model] System.status is deprecated; use System.lifecycle instead.')
+
+    warn.mockRestore()
+  })
+})
+
+describe('SystemEntrySchema - negative parse', () => {
+  it('rejects missing required fields', () => {
+    expect(SystemEntrySchema.safeParse({ id: 'sys.missing' }).success).toBe(false)
+  })
+
+  it('rejects an unknown system kind', () => {
+    expect(SystemEntrySchema.safeParse({ ...VALID_SYSTEM, kind: 'sales' }).success).toBe(false)
+  })
+
+  it('rejects an unknown deprecated system status', () => {
+    expect(SystemEntrySchema.safeParse({ ...VALID_SYSTEM, status: 'paused' }).success).toBe(false)
+  })
+
+  it('rejects IDs that do not match the OM model-id format', () => {
+    expect(SystemEntrySchema.safeParse({ ...VALID_SYSTEM, id: 'Sys Lead Gen' }).success).toBe(false)
+  })
+})
+
+describe('SystemsDomainSchema', () => {
+  it('accepts an empty systems record', () => {
+    expect(SystemsDomainSchema.safeParse({}).success).toBe(true)
+  })
+
+  it('defaults systems to an empty record when omitted', () => {
+    const result = SystemsDomainSchema.safeParse({})
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data).toEqual(DEFAULT_ORGANIZATION_MODEL_SYSTEMS)
+    }
+  })
+})
+
+describe('SystemKindSchema', () => {
+  it.each(['product', 'operational', 'platform', 'diagnostic'] as const)('accepts kind "%s"', (kind) => {
+    expect(SystemKindSchema.safeParse(kind).success).toBe(true)
+  })
+})
+
+describe('SystemStatusSchema', () => {
+  it.each(['active', 'deprecated', 'archived'] as const)('accepts deprecated status "%s"', (status) => {
+    expect(SystemStatusSchema.safeParse(status).success).toBe(true)
+  })
+})
+
+describe('resolveOrganizationModel - systems domain integration', () => {
+  it('omitting systems keeps default system entries', () => {
+    const model = resolveOrganizationModel({})
+
+    expect(Object.keys(model.systems).length).toBeGreaterThan(Object.keys(DEFAULT_ORGANIZATION_MODEL_SYSTEMS).length)
+    expect(model.systems['sales.crm']?.path).toBe('/crm')
+  })
+
+  it('accepts valid responsible role, knowledge, and goal references', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        roles: {
+          'role.sales-ops': { id: 'role.sales-ops', order: 10, title: 'Sales Ops' }
+        },
+        goals: {
+          'goal.pipeline-coverage': {
+            id: 'goal.pipeline-coverage',
+            order: 10,
+            description: 'Improve sales pipeline coverage',
+            periodStart: '2026-01-01',
+            periodEnd: '2026-12-31'
+          }
+        },
+        knowledge: {
+          'knowledge.lead-gen-playbook': {
+            id: 'knowledge.lead-gen-playbook',
+            kind: 'playbook',
+            title: 'Lead Gen Playbook',
+            summary: 'How lead generation is governed.',
+            body: '## Lead Gen',
+            updatedAt: '2026-05-08'
+          }
+        },
+        systems: {
+          'sys.lead-gen': {
+            ...VALID_SYSTEM,
+            responsibleRoleId: 'role.sales-ops',
+            governedByKnowledge: ['knowledge.lead-gen-playbook'],
+            drivesGoals: ['goal.pipeline-coverage']
+          }
+        }
+      })
+    ).not.toThrow()
+  })
+
+  it('throws when system IDs are duplicated', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        systems: {
+          'sys.lead-gen': VALID_SYSTEM,
+          'sys.lead-gen-dup': {
+            ...VALID_SYSTEM,
+            id: 'sys.lead-gen'
+          }
+        }
+      })
+    ).toThrow()
+  })
+
+  it('throws when responsibleRoleId references an unknown role', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        systems: {
+          'sys.lead-gen': { ...VALID_SYSTEM, responsibleRoleId: 'role.missing' }
+        }
+      })
+    ).toThrow(/unknown responsibleRoleId \\"role\.missing\\"/)
+  })
+
+  it('throws when governedByKnowledge references an unknown knowledge node', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        systems: {
+          'sys.lead-gen': { ...VALID_SYSTEM, governedByKnowledge: ['knowledge.missing'] }
+        }
+      })
+    ).toThrow(/unknown knowledge node \\"knowledge\.missing\\"/)
+  })
+
+  it('throws when drivesGoals references an unknown goal', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        systems: {
+          'sys.lead-gen': { ...VALID_SYSTEM, drivesGoals: ['goal.missing'] }
+        }
+      })
+    ).toThrow(/unknown goal \\"goal\.missing\\"/)
+  })
+})

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

@@ -0,0 +1,188 @@
+import { describe, expect, it } from 'vitest'
+import { ZodError } from 'zod'
+import {
+  OmTopologyDomainSchema,
+  OmTopologyMetadataSchema,
+  defineTopology,
+  defineTopologyRelationship,
+  parseTopologyNodeRef,
+  topologyRef
+} from '../../domains/topology'
+import { resolveOrganizationModel } from '../../resolve'
+
+const VALID_SYSTEM = {
+  id: 'sales',
+  order: 10,
+  label: 'Sales',
+  enabled: true,
+  lifecycle: 'active' as const
+}
+
+const SOURCE_RESOURCE = {
+  id: 'email-discovery',
+  order: 10,
+  kind: 'workflow' as const,
+  systemPath: 'sales',
+  status: 'active' as const
+}
+
+const TARGET_RESOURCE = {
+  id: 'email-verification',
+  order: 20,
+  kind: 'workflow' as const,
+  systemPath: 'sales',
+  status: 'active' as const
+}
+
+describe('OM topology domain', () => {
+  it('accepts first-class topology relationships', () => {
+    const model = resolveOrganizationModel({
+      systems: { sales: VALID_SYSTEM },
+      resources: {
+        'email-discovery': SOURCE_RESOURCE,
+        'email-verification': TARGET_RESOURCE
+      },
+      topology: {
+        version: 1,
+        relationships: {
+          'email-discovery-triggers-email-verification': {
+            from: { kind: 'resource', id: 'email-discovery' },
+            kind: 'triggers',
+            to: { kind: 'resource', id: 'email-verification' },
+            systemPath: 'sales',
+            required: true,
+            metadata: { source: 'authored' }
+          }
+        }
+      }
+    })
+
+    expect(model.topology.relationships['email-discovery-triggers-email-verification']).toMatchObject({
+      from: { kind: 'resource', id: 'email-discovery' },
+      kind: 'triggers',
+      to: { kind: 'resource', id: 'email-verification' },
+      required: true
+    })
+  })
+
+  it('rejects dangling first-class topology refs', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        systems: { sales: VALID_SYSTEM },
+        resources: { 'email-discovery': SOURCE_RESOURCE },
+        topology: {
+          version: 1,
+          relationships: {
+            'email-discovery-triggers-missing': {
+              from: { kind: 'resource', id: 'email-discovery' },
+              kind: 'triggers',
+              to: { kind: 'resource', id: 'missing-resource' }
+            }
+          }
+        }
+      })
+    ).toThrow(/unknown resource \\"missing-resource\\"/)
+  })
+
+  it('reports dangling topology refs on the relationship side path', () => {
+    let error: unknown
+
+    try {
+      resolveOrganizationModel({
+        systems: { sales: VALID_SYSTEM },
+        resources: { 'email-discovery': SOURCE_RESOURCE },
+        topology: {
+          version: 1,
+          relationships: {
+            'email-discovery-triggers-missing': {
+              from: { kind: 'resource', id: 'email-discovery' },
+              kind: 'triggers',
+              to: { kind: 'resource', id: 'missing-resource' }
+            }
+          }
+        }
+      })
+    } catch (caught) {
+      error = caught
+    }
+
+    expect(error).toBeInstanceOf(ZodError)
+    if (!(error instanceof ZodError)) {
+      throw new Error('Expected resolveOrganizationModel to throw a ZodError')
+    }
+    expect(error.issues).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          path: ['topology', 'relationships', 'email-discovery-triggers-missing', 'to']
+        })
+      ])
+    )
+  })
+
+  it('rejects secret-like topology metadata', () => {
+    expect(
+      OmTopologyMetadataSchema.safeParse({
+        owner: 'sales-ops',
+        credentials: { apiKey: 'sk-test-12345678901234567890' }
+      }).success
+    ).toBe(false)
+  })
+
+  it('compiles typed resource objects through authoring helpers', () => {
+    const relationship = defineTopologyRelationship({
+      from: SOURCE_RESOURCE,
+      kind: 'uses',
+      to: topologyRef.externalResource('apollo'),
+      required: true
+    })
+
+    expect(relationship).toEqual({
+      from: { kind: 'resource', id: 'email-discovery' },
+      kind: 'uses',
+      to: { kind: 'externalResource', id: 'apollo' },
+      required: true
+    })
+
+    expect(
+      defineTopology({
+        'email-discovery-uses-apollo': {
+          from: SOURCE_RESOURCE,
+          kind: 'uses',
+          to: topologyRef.externalResource('apollo')
+        }
+      })
+    ).toMatchObject({
+      version: 1,
+      relationships: {
+        'email-discovery-uses-apollo': {
+          from: { kind: 'resource', id: 'email-discovery' },
+          to: { kind: 'externalResource', id: 'apollo' }
+        }
+      }
+    })
+  })
+
+  it('parses boundary string refs without making raw strings canonical', () => {
+    expect(parseTopologyNodeRef('resource:email-discovery')).toEqual({
+      kind: 'resource',
+      id: 'email-discovery'
+    })
+    expect(parseTopologyNodeRef('ontology:sales:action/contact.verify-email')).toEqual({
+      kind: 'ontology',
+      id: 'sales:action/contact.verify-email'
+    })
+    expect(() => parseTopologyNodeRef('email-discovery')).toThrow(/must use <kind>:<id>/)
+    expect(() =>
+      OmTopologyDomainSchema.parse({
+        version: 1,
+        relationships: {
+          invalid: {
+            from: 'resource:email-discovery',
+            kind: 'uses',
+            to: { kind: 'resource', id: 'email-verification' }
+          }
+        }
+      })
+    ).toThrow()
+  })
+})