@elevasis/core 0.23.0 → 0.24.1

package/src/platform/registry/__tests__/resource-registry.integration.test.ts

@@ -32,14 +32,14 @@ describe('ResourceRegistry Integration', () => {
   // Mock Data Helpers
   // ============================================================================
 
-  const createMockWorkflow = (resourceId: string, status: 'dev' | 'prod' = 'dev'): WorkflowDefinition => ({
+  const createMockWorkflow = (resourceId: string, status: 'dev' | 'prod' = 'dev'): WorkflowDefinition => ({
     config: {
       resourceId,
       name: `Workflow ${resourceId}`,
       description: `Test workflow ${resourceId}`,
-      version: '1.0.0',
-      type: 'workflow',
-      status
+      version: '1.0.0',
+      type: 'workflow',
+      status
     },
     contract: {
       inputSchema: z.object({ data: z.string() }),
@@ -59,15 +59,15 @@ describe('ResourceRegistry Integration', () => {
     entryPoint: 'step1'
   })
 
-  const createMockAgent = (resourceId: string, status: 'dev' | 'prod' = 'dev'): AgentDefinition => ({
+  const createMockAgent = (resourceId: string, status: 'dev' | 'prod' = 'dev'): AgentDefinition => ({
     config: {
       resourceId,
       name: `Agent ${resourceId}`,
       description: `Test agent ${resourceId}`,
       version: '1.0.0',
-      type: 'agent',
-      status,
-      systemPrompt: 'You are a test agent'
+      type: 'agent',
+      status,
+      systemPrompt: 'You are a test agent'
     },
     contract: {
       inputSchema: z.object({ query: z.string() }),
@@ -87,13 +87,13 @@ describe('ResourceRegistry Integration', () => {
    */
   const createTestOrganization = (): DeploymentSpec => {
     const workflows = [
-      createMockWorkflow('order-workflow', 'prod'),
-      createMockWorkflow('support-workflow', 'dev')
+      createMockWorkflow('order-workflow', 'prod'),
+      createMockWorkflow('support-workflow', 'dev')
     ]
 
     const agents = [
-      createMockAgent('order-agent', 'prod'),
-      createMockAgent('support-agent', 'dev')
+      createMockAgent('order-agent', 'prod'),
+      createMockAgent('support-agent', 'dev')
     ]
 
     const triggers: TriggerDefinition[] = [
@@ -105,7 +105,7 @@ describe('ResourceRegistry Integration', () => {
         name: 'Order Webhook',
         description: 'Webhook from Shopify on new orders',
         status: 'prod',
-        webhookPath: '/webhooks/shopify/orders'
+        webhookPath: '/webhooks/shopify/orders'
       },
       {
         resourceId: 'trigger-schedule-support',
@@ -114,8 +114,8 @@ describe('ResourceRegistry Integration', () => {
         version: '1.0.0',
         name: 'Support Ticket Check',
         description: 'Check for new support tickets every hour',
-        status: 'dev',
-        schedule: '0 * * * *'
+        status: 'dev',
+        schedule: '0 * * * *'
       },
       {
         resourceId: 'trigger-manual-test',
@@ -136,8 +136,8 @@ describe('ResourceRegistry Integration', () => {
         status: 'prod',
         provider: 'shopify',
         credentialName: 'shopify-prod',
-        name: 'Shopify Production',
-        description: 'E-commerce platform'
+        name: 'Shopify Production',
+        description: 'E-commerce platform'
       },
       {
         resourceId: 'integration-zendesk',
@@ -146,8 +146,8 @@ describe('ResourceRegistry Integration', () => {
         status: 'dev',
         provider: 'zendesk',
         credentialName: 'zendesk-dev',
-        name: 'Zendesk Support',
-        description: 'Support ticket system'
+        name: 'Zendesk Support',
+        description: 'Support ticket system'
       }
     ]
 
@@ -187,7 +187,7 @@ describe('ResourceRegistry Integration', () => {
         description: 'Approve orders over $10,000',
         status: 'prod',
         requestedBy: { agents: ['order-agent'] },
-        routesTo: { workflows: ['order-workflow'] }
+        routesTo: { workflows: ['order-workflow'] }
       },
       {
         resourceId: 'approval-escalation',

package/src/platform/registry/__tests__/resource-registry.nested-systems.test.ts

@@ -1,245 +1,245 @@
-/**
- * Regression tests for resource-registry nested-systems lookup (Wave 1 hotfix).
- *
- * Before the fix, `listResourcesForOrganization` built the systems map with
- * `Object.values(org.systems)`, which only surfaced top-level entries. Systems
- * declared as children under `system.subsystems` were invisible, so
- * `summarizeSystem` always returned `undefined` for nested paths.
- *
- * After the fix, the map is built via `listAllSystems` (DFS), which walks the
- * full tree and keys every entry by its dot-joined path.
- */
-import { describe, it, expect } from 'vitest'
-import { z } from 'zod'
-import { ResourceRegistry } from '../resource-registry'
-import type { SystemEntry } from '../../../organization-model/domains/systems'
-import type { ResourceEntry } from '../../../organization-model/domains/resources'
-import type { WorkflowDefinition } from '../../../execution/engine/workflow/types'
-
-// ---------------------------------------------------------------------------
-// Minimal fixture helpers
-// ---------------------------------------------------------------------------
-
-function makeWorkflow(resourceId: string, resource?: ResourceEntry): WorkflowDefinition {
-  return {
-    config: {
-      resourceId,
-      name: `Workflow ${resourceId}`,
-      description: `Test workflow ${resourceId}`,
-      version: '1.0.0',
-      type: 'workflow',
-      status: 'prod',
-      resource
-    },
-    contract: {
-      inputSchema: z.object({ input: z.string() }),
-      outputSchema: z.object({ output: z.string() })
-    },
-    steps: {
-      step1: {
-        id: 'step1',
-        name: 'Step 1',
-        description: 'Only step',
-        handler: async () => ({ output: 'ok' }),
-        inputSchema: z.object({ input: z.string() }),
-        outputSchema: z.object({ output: z.string() }),
-        next: null
-      }
-    },
-    entryPoint: 'step1'
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Fixture: two-level system tree
-//
-//   systems
-//   └── acquisition          (top-level, id: 'acquisition')
-//       └── subsystems
-//           └── outbound     (nested, id: 'outbound')  ← formerly invisible
-// ---------------------------------------------------------------------------
-
-const topLevelSystem: SystemEntry = {
-  id: 'acquisition',
-  label: 'Acquisition',
-  description: 'Top-level acquisition system.',
-  kind: 'operational',
-  governedByKnowledge: [],
-  drivesGoals: [],
-  lifecycle: 'active',
-  order: 10
-}
-
-const nestedSystem: SystemEntry = {
-  id: 'outbound',
-  label: 'Outbound',
-  description: 'Outbound automation sub-system.',
-  kind: 'operational',
-  governedByKnowledge: [],
-  drivesGoals: [],
-  lifecycle: 'active',
-  order: 10
-}
-
-/** Dot-joined path for the nested system as it appears in resource.systemPath */
-const NESTED_SYSTEM_PATH = 'acquisition.outbound'
-
-const topLevelSystemWithChildren: SystemEntry = {
-  ...topLevelSystem,
-  subsystems: {
-    outbound: nestedSystem
-  }
-}
-
-const nestedSystemResource: ResourceEntry = {
-  id: 'cold-outreach-workflow',
-  kind: 'workflow',
-  systemPath: NESTED_SYSTEM_PATH,
-  status: 'active',
-  order: 10
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('ResourceRegistry — nested-systems lookup regression', () => {
-  it('resolves system metadata for a TOP-LEVEL system path', () => {
-    const topResource: ResourceEntry = {
-      id: 'top-workflow',
-      kind: 'workflow',
-      systemPath: 'acquisition',
-      status: 'active',
-      order: 10
-    }
-    const workflow = makeWorkflow('top-workflow', topResource)
-
-    const registry = new ResourceRegistry({
-      'test-org': {
-        version: '1.0.0',
-        organizationModel: {
-          systems: { acquisition: topLevelSystemWithChildren },
-          resources: { 'top-workflow': topResource }
-        },
-        workflows: [workflow]
-      }
-    })
-
-    const result = registry.listResourcesForOrganization('test-org')
-
-    expect(result.workflows).toHaveLength(1)
-    expect(result.workflows[0].system).toBeDefined()
-    expect(result.workflows[0].system).toMatchObject({
-      id: 'acquisition',
-      title: 'Acquisition',
-      kind: 'operational',
-      lifecycle: 'active'
-    })
-    expect(result.workflows[0].systemPath).toBe('acquisition')
-  })
-
-  it('resolves system metadata for a NESTED system path (the regression case)', () => {
-    const workflow = makeWorkflow('cold-outreach-workflow', nestedSystemResource)
-
-    const registry = new ResourceRegistry({
-      'test-org': {
-        version: '1.0.0',
-        organizationModel: {
-          // The nested system lives under acquisition.subsystems, NOT as a top-level key.
-          // Before the fix, Object.values(systems) missed this entirely.
-          systems: { acquisition: topLevelSystemWithChildren },
-          resources: { 'cold-outreach-workflow': nestedSystemResource }
-        },
-        workflows: [workflow]
-      }
-    })
-
-    const result = registry.listResourcesForOrganization('test-org')
-
-    expect(result.workflows).toHaveLength(1)
-    // Before the fix this was undefined; it must now be defined.
-    expect(result.workflows[0].system).toBeDefined()
-    expect(result.workflows[0].system).toMatchObject({
-      id: 'outbound',
-      title: 'Outbound',
-      kind: 'operational',
-      lifecycle: 'active'
-    })
-    expect(result.workflows[0].systemPath).toBe(NESTED_SYSTEM_PATH)
-    expect(result.workflows[0].governanceStatus).toBe('active')
-  })
-
-  it('resolves system metadata for a THREE-level nested path', () => {
-    const deepSystem: SystemEntry = {
-      id: 'sequences',
-      label: 'Sequences',
-      description: 'Email sequence sub-sub-system.',
-      kind: 'operational',
-      governedByKnowledge: [],
-      drivesGoals: [],
-      lifecycle: 'active',
-      order: 10
-    }
-
-    const outboundWithChildren: SystemEntry = {
-      ...nestedSystem,
-      subsystems: { sequences: deepSystem }
-    }
-
-    const topWithDeepNesting: SystemEntry = {
-      ...topLevelSystem,
-      subsystems: { outbound: outboundWithChildren }
-    }
-
-    const deepResource: ResourceEntry = {
-      id: 'sequence-enroller',
-      kind: 'workflow',
-      systemPath: 'acquisition.outbound.sequences',
-      status: 'active',
-      order: 10
-    }
-
-    const workflow = makeWorkflow('sequence-enroller', deepResource)
-
-    const registry = new ResourceRegistry({
-      'test-org': {
-        version: '1.0.0',
-        organizationModel: {
-          systems: { acquisition: topWithDeepNesting },
-          resources: { 'sequence-enroller': deepResource }
-        },
-        workflows: [workflow]
-      }
-    })
-
-    const result = registry.listResourcesForOrganization('test-org')
-
-    expect(result.workflows).toHaveLength(1)
-    expect(result.workflows[0].system).toBeDefined()
-    expect(result.workflows[0].system).toMatchObject({
-      id: 'sequences',
-      title: 'Sequences',
-      lifecycle: 'active'
-    })
-    expect(result.workflows[0].systemPath).toBe('acquisition.outbound.sequences')
-  })
-
-  it('returns undefined system when the workflow has no resource descriptor and no OM entry', () => {
-    // A workflow with no OM resource descriptor and no organizationModel at all
-    // should leave system undefined (no governance metadata attached).
-    const workflow = makeWorkflow('bare-workflow')
-
-    const registry = new ResourceRegistry({
-      'test-org': {
-        version: '1.0.0',
-        workflows: [workflow]
-      }
-    })
-
-    const result = registry.listResourcesForOrganization('test-org')
-
-    expect(result.workflows).toHaveLength(1)
-    expect(result.workflows[0].system).toBeUndefined()
-    expect(result.workflows[0].systemPath).toBeUndefined()
-  })
-})
+/**
+ * Regression tests for resource-registry nested-systems lookup (Wave 1 hotfix).
+ *
+ * Before the fix, `listResourcesForOrganization` built the systems map with
+ * `Object.values(org.systems)`, which only surfaced top-level entries. Systems
+ * declared as children under `system.subsystems` were invisible, so
+ * `summarizeSystem` always returned `undefined` for nested paths.
+ *
+ * After the fix, the map is built via `listAllSystems` (DFS), which walks the
+ * full tree and keys every entry by its dot-joined path.
+ */
+import { describe, it, expect } from 'vitest'
+import { z } from 'zod'
+import { ResourceRegistry } from '../resource-registry'
+import type { SystemEntry } from '../../../organization-model/domains/systems'
+import type { ResourceEntry } from '../../../organization-model/domains/resources'
+import type { WorkflowDefinition } from '../../../execution/engine/workflow/types'
+
+// ---------------------------------------------------------------------------
+// Minimal fixture helpers
+// ---------------------------------------------------------------------------
+
+function makeWorkflow(resourceId: string, resource?: ResourceEntry): WorkflowDefinition {
+  return {
+    config: {
+      resourceId,
+      name: `Workflow ${resourceId}`,
+      description: `Test workflow ${resourceId}`,
+      version: '1.0.0',
+      type: 'workflow',
+      status: 'prod',
+      resource
+    },
+    contract: {
+      inputSchema: z.object({ input: z.string() }),
+      outputSchema: z.object({ output: z.string() })
+    },
+    steps: {
+      step1: {
+        id: 'step1',
+        name: 'Step 1',
+        description: 'Only step',
+        handler: async () => ({ output: 'ok' }),
+        inputSchema: z.object({ input: z.string() }),
+        outputSchema: z.object({ output: z.string() }),
+        next: null
+      }
+    },
+    entryPoint: 'step1'
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Fixture: two-level system tree
+//
+//   systems
+//   └── acquisition          (top-level, id: 'acquisition')
+//       └── subsystems
+//           └── outbound     (nested, id: 'outbound')  ← formerly invisible
+// ---------------------------------------------------------------------------
+
+const topLevelSystem: SystemEntry = {
+  id: 'acquisition',
+  label: 'Acquisition',
+  description: 'Top-level acquisition system.',
+  kind: 'operational',
+  governedByKnowledge: [],
+  drivesGoals: [],
+  lifecycle: 'active',
+  order: 10
+}
+
+const nestedSystem: SystemEntry = {
+  id: 'outbound',
+  label: 'Outbound',
+  description: 'Outbound automation sub-system.',
+  kind: 'operational',
+  governedByKnowledge: [],
+  drivesGoals: [],
+  lifecycle: 'active',
+  order: 10
+}
+
+/** Dot-joined path for the nested system as it appears in resource.systemPath */
+const NESTED_SYSTEM_PATH = 'acquisition.outbound'
+
+const topLevelSystemWithChildren: SystemEntry = {
+  ...topLevelSystem,
+  subsystems: {
+    outbound: nestedSystem
+  }
+}
+
+const nestedSystemResource: ResourceEntry = {
+  id: 'cold-outreach-workflow',
+  kind: 'workflow',
+  systemPath: NESTED_SYSTEM_PATH,
+  status: 'active',
+  order: 10
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('ResourceRegistry — nested-systems lookup regression', () => {
+  it('resolves system metadata for a TOP-LEVEL system path', () => {
+    const topResource: ResourceEntry = {
+      id: 'top-workflow',
+      kind: 'workflow',
+      systemPath: 'acquisition',
+      status: 'active',
+      order: 10
+    }
+    const workflow = makeWorkflow('top-workflow', topResource)
+
+    const registry = new ResourceRegistry({
+      'test-org': {
+        version: '1.0.0',
+        organizationModel: {
+          systems: { acquisition: topLevelSystemWithChildren },
+          resources: { 'top-workflow': topResource }
+        },
+        workflows: [workflow]
+      }
+    })
+
+    const result = registry.listResourcesForOrganization('test-org')
+
+    expect(result.workflows).toHaveLength(1)
+    expect(result.workflows[0].system).toBeDefined()
+    expect(result.workflows[0].system).toMatchObject({
+      id: 'acquisition',
+      title: 'Acquisition',
+      kind: 'operational',
+      lifecycle: 'active'
+    })
+    expect(result.workflows[0].systemPath).toBe('acquisition')
+  })
+
+  it('resolves system metadata for a NESTED system path (the regression case)', () => {
+    const workflow = makeWorkflow('cold-outreach-workflow', nestedSystemResource)
+
+    const registry = new ResourceRegistry({
+      'test-org': {
+        version: '1.0.0',
+        organizationModel: {
+          // The nested system lives under acquisition.subsystems, NOT as a top-level key.
+          // Before the fix, Object.values(systems) missed this entirely.
+          systems: { acquisition: topLevelSystemWithChildren },
+          resources: { 'cold-outreach-workflow': nestedSystemResource }
+        },
+        workflows: [workflow]
+      }
+    })
+
+    const result = registry.listResourcesForOrganization('test-org')
+
+    expect(result.workflows).toHaveLength(1)
+    // Before the fix this was undefined; it must now be defined.
+    expect(result.workflows[0].system).toBeDefined()
+    expect(result.workflows[0].system).toMatchObject({
+      id: 'outbound',
+      title: 'Outbound',
+      kind: 'operational',
+      lifecycle: 'active'
+    })
+    expect(result.workflows[0].systemPath).toBe(NESTED_SYSTEM_PATH)
+    expect(result.workflows[0].governanceStatus).toBe('active')
+  })
+
+  it('resolves system metadata for a THREE-level nested path', () => {
+    const deepSystem: SystemEntry = {
+      id: 'sequences',
+      label: 'Sequences',
+      description: 'Email sequence sub-sub-system.',
+      kind: 'operational',
+      governedByKnowledge: [],
+      drivesGoals: [],
+      lifecycle: 'active',
+      order: 10
+    }
+
+    const outboundWithChildren: SystemEntry = {
+      ...nestedSystem,
+      subsystems: { sequences: deepSystem }
+    }
+
+    const topWithDeepNesting: SystemEntry = {
+      ...topLevelSystem,
+      subsystems: { outbound: outboundWithChildren }
+    }
+
+    const deepResource: ResourceEntry = {
+      id: 'sequence-enroller',
+      kind: 'workflow',
+      systemPath: 'acquisition.outbound.sequences',
+      status: 'active',
+      order: 10
+    }
+
+    const workflow = makeWorkflow('sequence-enroller', deepResource)
+
+    const registry = new ResourceRegistry({
+      'test-org': {
+        version: '1.0.0',
+        organizationModel: {
+          systems: { acquisition: topWithDeepNesting },
+          resources: { 'sequence-enroller': deepResource }
+        },
+        workflows: [workflow]
+      }
+    })
+
+    const result = registry.listResourcesForOrganization('test-org')
+
+    expect(result.workflows).toHaveLength(1)
+    expect(result.workflows[0].system).toBeDefined()
+    expect(result.workflows[0].system).toMatchObject({
+      id: 'sequences',
+      title: 'Sequences',
+      lifecycle: 'active'
+    })
+    expect(result.workflows[0].systemPath).toBe('acquisition.outbound.sequences')
+  })
+
+  it('returns undefined system when the workflow has no resource descriptor and no OM entry', () => {
+    // A workflow with no OM resource descriptor and no organizationModel at all
+    // should leave system undefined (no governance metadata attached).
+    const workflow = makeWorkflow('bare-workflow')
+
+    const registry = new ResourceRegistry({
+      'test-org': {
+        version: '1.0.0',
+        workflows: [workflow]
+      }
+    })
+
+    const result = registry.listResourcesForOrganization('test-org')
+
+    expect(result.workflows).toHaveLength(1)
+    expect(result.workflows[0].system).toBeUndefined()
+    expect(result.workflows[0].systemPath).toBeUndefined()
+  })
+})