@elevasis/core 0.22.0 → 0.23.0

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

@@ -1,7 +1,9 @@
 import { describe, expect, it } from 'vitest'
+import { ZodError } from 'zod'
 import { bindResourceDescriptor } from '../../../platform/registry/types'
 import {
   DEFAULT_ORGANIZATION_MODEL_RESOURCES,
+  EventIdSchema,
   ResourceEntrySchema,
   ResourceKindSchema,
   ResourcesDomainSchema,
@@ -12,6 +14,7 @@ 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,
@@ -20,55 +23,81 @@ const VALID_SYSTEM = {
 
 const VALID_ROLE = {
   id: 'role.sales-ops',
+  order: 10,
   title: 'Sales Ops'
 }
 
 const WORKFLOW_RESOURCE = {
   id: 'LGN-01-company-scrape',
+  order: 10,
   kind: 'workflow' as const,
-  systemId: 'sys.lead-gen',
+  systemPath: 'sys.lead-gen',
   ownerRoleId: 'role.sales-ops',
   status: 'active' as const,
-  capabilityKey: 'lead-gen.company.scrape'
+  actionKey: 'lead-gen.company.scrape'
+}
+
+const WORKFLOW_EVENT_EMISSION = {
+  eventKey: 'processed',
+  label: 'Processed',
+  payloadSchema: 'leadgen.company.processed',
+  lifecycle: 'active' as const
 }
 
 const AGENT_RESOURCE = {
   id: 'command-center-assistant',
+  order: 20,
   kind: 'agent' as const,
-  systemId: 'sys.lead-gen',
+  systemPath: 'sys.lead-gen',
   ownerRoleId: 'role.sales-ops',
   status: 'active' as const,
-  agentKind: 'system' as const,
+  agentKind: 'platform' as const,
   actsAsRoleId: 'role.sales-ops',
-  sessionCapable: true
+  sessionCapable: true,
+  invocations: [{ kind: 'slash-command' as const, command: '/work handoff' }]
 }
 
 const INTEGRATION_RESOURCE = {
   id: 'attio-crm',
+  order: 30,
   kind: 'integration' as const,
-  systemId: 'sys.lead-gen',
+  systemPath: 'sys.lead-gen',
   ownerRoleId: 'role.sales-ops',
   status: 'active' as const,
   provider: 'attio'
 }
 
-function resolveWithResources(resources: unknown[]) {
+const SCRIPT_RESOURCE = {
+  id: 'leadgen-backfill-script',
+  order: 40,
+  kind: 'script' as const,
+  systemPath: 'sys.lead-gen',
+  ownerRoleId: 'role.sales-ops',
+  status: 'active' as const,
+  language: 'typescript' as const,
+  source: {
+    file: 'scripts/leadgen/backfill.ts'
+  }
+}
+
+function resolveWithResources(resources: Record<string, unknown>) {
   return resolveOrganizationModel({
-    roles: { roles: [VALID_ROLE] },
-    systems: { systems: [VALID_SYSTEM] },
-    resources: { entries: resources }
+    roles: { 'role.sales-ops': VALID_ROLE },
+    systems: { 'sys.lead-gen': VALID_SYSTEM },
+    resources: resources as Record<string, typeof WORKFLOW_RESOURCE>
   })
 }
 
 describe('ResourceEntrySchema', () => {
-  it('accepts workflow, agent, and integration descriptors with required systemId', () => {
+  it('accepts workflow, agent, integration, and script descriptors with required systemPath', () => {
     expect(ResourceEntrySchema.safeParse(WORKFLOW_RESOURCE).success).toBe(true)
     expect(ResourceEntrySchema.safeParse(AGENT_RESOURCE).success).toBe(true)
     expect(ResourceEntrySchema.safeParse(INTEGRATION_RESOURCE).success).toBe(true)
+    expect(ResourceEntrySchema.safeParse(SCRIPT_RESOURCE).success).toBe(true)
   })
 
-  it('rejects resources without a systemId', () => {
-    const { systemId: _systemId, ...resourceWithoutSystem } = WORKFLOW_RESOURCE
+  it('rejects resources without a systemPath', () => {
+    const { systemPath: _systemPath, ...resourceWithoutSystem } = WORKFLOW_RESOURCE
 
     expect(ResourceEntrySchema.safeParse(resourceWithoutSystem).success).toBe(false)
   })
@@ -77,7 +106,7 @@ describe('ResourceEntrySchema', () => {
     expect(
       ResourceEntrySchema.safeParse({
         ...WORKFLOW_RESOURCE,
-        systemId: ['sys.lead-gen', 'sys.crm']
+        systemPath: ['sys.lead-gen', 'sys.crm']
       }).success
     ).toBe(false)
   })
@@ -90,10 +119,70 @@ describe('ResourceEntrySchema', () => {
       }).success
     ).toBe(false)
   })
+
+  it('defaults agent invocations and accepts slash-command orchestration entries', () => {
+    const result = ResourceEntrySchema.safeParse({
+      ...AGENT_RESOURCE,
+      invocations: undefined
+    })
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.kind).toBe('agent')
+      if (result.data.kind === 'agent') {
+        expect(result.data.invocations).toEqual([])
+      }
+    }
+
+    expect(ResourceEntrySchema.safeParse(AGENT_RESOURCE).success).toBe(true)
+  })
+
+  it('rejects malformed agent invocation entries', () => {
+    expect(
+      ResourceEntrySchema.safeParse({
+        ...AGENT_RESOURCE,
+        invocations: [{ kind: 'slash-command', command: 'work handoff' }]
+      }).success
+    ).toBe(false)
+  })
+
+  it('accepts event emissions on workflow and agent resources only', () => {
+    const workflowResult = ResourceEntrySchema.safeParse({
+      ...WORKFLOW_RESOURCE,
+      emits: [WORKFLOW_EVENT_EMISSION]
+    })
+    const agentResult = ResourceEntrySchema.safeParse({
+      ...AGENT_RESOURCE,
+      emits: [{ eventKey: 'approved', label: 'Approved' }]
+    })
+    const integrationResult = ResourceEntrySchema.safeParse({
+      ...INTEGRATION_RESOURCE,
+      emits: [{ eventKey: 'received', label: 'Received' }]
+    })
+
+    expect(workflowResult.success).toBe(true)
+    expect(agentResult.success).toBe(true)
+    expect(integrationResult.success).toBe(true)
+    if (workflowResult.success && workflowResult.data.kind === 'workflow') {
+      expect(workflowResult.data.emits).toEqual([WORKFLOW_EVENT_EMISSION])
+    }
+    if (agentResult.success && agentResult.data.kind === 'agent') {
+      expect(agentResult.data.emits).toEqual([{ eventKey: 'approved', label: 'Approved' }])
+    }
+    if (integrationResult.success && integrationResult.data.kind === 'integration') {
+      expect('emits' in integrationResult.data).toBe(false)
+    }
+  })
+
+  it('validates derived event id format', () => {
+    expect(EventIdSchema.parse('crm.deal:won')).toBe('crm.deal:won')
+    expect(EventIdSchema.parse('LGN-01-company-scrape:processed')).toBe('LGN-01-company-scrape:processed')
+    expect(() => EventIdSchema.parse('crm.deal.won')).toThrow()
+  })
 })
 
 describe('ResourcesDomainSchema', () => {
-  it('defaults resources to an empty array when omitted', () => {
+  it('defaults resources to an empty record when omitted', () => {
     const result = ResourcesDomainSchema.safeParse({})
 
     expect(result.success).toBe(true)
@@ -102,60 +191,93 @@ describe('ResourcesDomainSchema', () => {
     }
   })
 
-  it.each(['workflow', 'agent', 'integration'] as const)('accepts kind "%s"', (kind) => {
+  it.each(['workflow', 'agent', 'integration', 'script'] as const)('accepts kind "%s"', (kind) => {
     expect(ResourceKindSchema.safeParse(kind).success).toBe(true)
   })
 })
 
 describe('resolveOrganizationModel - resources domain integration', () => {
   it('accepts valid resources with system and role references', () => {
-    const model = resolveWithResources([WORKFLOW_RESOURCE, AGENT_RESOURCE, INTEGRATION_RESOURCE])
+    const model = resolveWithResources({
+      'LGN-01-company-scrape': WORKFLOW_RESOURCE,
+      'command-center-assistant': AGENT_RESOURCE,
+      'attio-crm': INTEGRATION_RESOURCE,
+      'leadgen-backfill-script': SCRIPT_RESOURCE
+    })
 
-    expect(model.resources.entries).toHaveLength(3)
+    expect(Object.keys(model.resources)).toHaveLength(4)
   })
 
-  it('throws when resource IDs are duplicated', () => {
+  it('throws when a resource entry id does not match its map key', () => {
     expect(() =>
-      resolveWithResources([
-        WORKFLOW_RESOURCE,
-        {
+      resolveWithResources({
+        'LGN-01-company-scrape': WORKFLOW_RESOURCE,
+        'wrong-key': {
           ...WORKFLOW_RESOURCE,
-          capabilityKey: 'lead-gen.company.scrape-duplicate'
+          id: 'LGN-01-company-scrape'
         }
-      ])
-    ).toThrow(/Resource id \\"LGN-01-company-scrape\\" must be unique/)
+      })
+    ).toThrow()
   })
 
-  it('throws when systemId references an unknown system', () => {
+  it('throws when systemPath references an unknown system', () => {
     expect(() =>
-      resolveWithResources([
-        {
+      resolveWithResources({
+        'LGN-01-company-scrape': {
           ...WORKFLOW_RESOURCE,
-          systemId: 'sys.missing'
+          systemPath: 'sys.missing'
         }
+      })
+    ).toThrow(/unknown system path \\"sys\.missing\\"/)
+  })
+
+  it('reports a dangling resource systemPath on the resource systemPath issue path', () => {
+    let error: unknown
+
+    try {
+      resolveWithResources({
+        'LGN-01-company-scrape': {
+          ...WORKFLOW_RESOURCE,
+          systemPath: 'sys.missing'
+        }
+      })
+    } 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: ['resources', 'LGN-01-company-scrape', 'systemPath']
+        })
       ])
-    ).toThrow(/unknown systemId \\"sys\.missing\\"/)
+    )
   })
 
   it('throws when ownerRoleId references an unknown role', () => {
     expect(() =>
-      resolveWithResources([
-        {
+      resolveWithResources({
+        'LGN-01-company-scrape': {
           ...WORKFLOW_RESOURCE,
           ownerRoleId: 'role.missing'
         }
-      ])
+      })
     ).toThrow(/unknown ownerRoleId \\"role\.missing\\"/)
   })
 
   it('throws when agent actsAsRoleId references an unknown role', () => {
     expect(() =>
-      resolveWithResources([
-        {
+      resolveWithResources({
+        'command-center-assistant': {
           ...AGENT_RESOURCE,
           actsAsRoleId: 'role.missing'
         }
-      ])
+      })
     ).toThrow(/unknown actsAsRoleId \\"role\.missing\\"/)
   })
 })
@@ -169,7 +291,7 @@ describe('descriptor helper contract', () => {
     })
 
     expect(workflow.id).toBe('LGN-01-company-scrape')
-    expect(resources.commandCenterAssistant.agentKind).toBe('system')
+    expect(resources.commandCenterAssistant.agentKind).toBe('platform')
   })
 
   it('derives runtime resourceId and type from the descriptor', () => {