@elevasis/core 0.21.0 → 0.23.0

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

@@ -0,0 +1,310 @@
+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,
+  defineResource,
+  defineResources
+} from '../../domains/resources'
+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,
+  status: 'active' as const
+}
+
+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,
+  systemPath: 'sys.lead-gen',
+  ownerRoleId: 'role.sales-ops',
+  status: 'active' as const,
+  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,
+  systemPath: 'sys.lead-gen',
+  ownerRoleId: 'role.sales-ops',
+  status: 'active' as const,
+  agentKind: 'platform' as const,
+  actsAsRoleId: 'role.sales-ops',
+  sessionCapable: true,
+  invocations: [{ kind: 'slash-command' as const, command: '/work handoff' }]
+}
+
+const INTEGRATION_RESOURCE = {
+  id: 'attio-crm',
+  order: 30,
+  kind: 'integration' as const,
+  systemPath: 'sys.lead-gen',
+  ownerRoleId: 'role.sales-ops',
+  status: 'active' as const,
+  provider: 'attio'
+}
+
+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: { '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, 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 systemPath', () => {
+    const { systemPath: _systemPath, ...resourceWithoutSystem } = WORKFLOW_RESOURCE
+
+    expect(ResourceEntrySchema.safeParse(resourceWithoutSystem).success).toBe(false)
+  })
+
+  it('rejects multi-system membership', () => {
+    expect(
+      ResourceEntrySchema.safeParse({
+        ...WORKFLOW_RESOURCE,
+        systemPath: ['sys.lead-gen', 'sys.crm']
+      }).success
+    ).toBe(false)
+  })
+
+  it('rejects an agent kind outside the code-side mirror enum', () => {
+    expect(
+      ResourceEntrySchema.safeParse({
+        ...AGENT_RESOURCE,
+        agentKind: 'runner'
+      }).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 record when omitted', () => {
+    const result = ResourcesDomainSchema.safeParse({})
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data).toEqual(DEFAULT_ORGANIZATION_MODEL_RESOURCES)
+    }
+  })
+
+  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({
+      'LGN-01-company-scrape': WORKFLOW_RESOURCE,
+      'command-center-assistant': AGENT_RESOURCE,
+      'attio-crm': INTEGRATION_RESOURCE,
+      'leadgen-backfill-script': SCRIPT_RESOURCE
+    })
+
+    expect(Object.keys(model.resources)).toHaveLength(4)
+  })
+
+  it('throws when a resource entry id does not match its map key', () => {
+    expect(() =>
+      resolveWithResources({
+        'LGN-01-company-scrape': WORKFLOW_RESOURCE,
+        'wrong-key': {
+          ...WORKFLOW_RESOURCE,
+          id: 'LGN-01-company-scrape'
+        }
+      })
+    ).toThrow()
+  })
+
+  it('throws when systemPath references an unknown system', () => {
+    expect(() =>
+      resolveWithResources({
+        'LGN-01-company-scrape': {
+          ...WORKFLOW_RESOURCE,
+          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']
+        })
+      ])
+    )
+  })
+
+  it('throws when ownerRoleId references an unknown role', () => {
+    expect(() =>
+      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({
+        'command-center-assistant': {
+          ...AGENT_RESOURCE,
+          actsAsRoleId: 'role.missing'
+        }
+      })
+    ).toThrow(/unknown actsAsRoleId \\"role\.missing\\"/)
+  })
+})
+
+describe('descriptor helper contract', () => {
+  it('preserves typed descriptor exports through defineResource and defineResources', () => {
+    const workflow = defineResource(WORKFLOW_RESOURCE)
+    const resources = defineResources({
+      companyScrape: WORKFLOW_RESOURCE,
+      commandCenterAssistant: AGENT_RESOURCE
+    })
+
+    expect(workflow.id).toBe('LGN-01-company-scrape')
+    expect(resources.commandCenterAssistant.agentKind).toBe('platform')
+  })
+
+  it('derives runtime resourceId and type from the descriptor', () => {
+    const bound = bindResourceDescriptor({
+      resource: WORKFLOW_RESOURCE,
+      name: 'Company Scrape',
+      description: 'Scrapes company data for lead generation.',
+      version: '1.0.0',
+      status: 'prod'
+    })
+
+    expect(bound.resourceId).toBe('LGN-01-company-scrape')
+    expect(bound.type).toBe('workflow')
+    expect(bound.resource).toBe(WORKFLOW_RESOURCE)
+  })
+})