@elevasis/core 0.24.0 → 0.24.1

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

@@ -31,12 +31,13 @@ const VALID_ROLE = {
 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',
-  codeRefs: [
+  kind: 'workflow' as const,
+  systemPath: 'sys.lead-gen',
+  title: 'Company Scrape',
+  description: 'Scrapes company data for lead generation.',
+  ownerRoleId: 'role.sales-ops',
+  status: 'active' as const,
+  codeRefs: [
     {
       path: 'operations/src/lead-gen/company-scrape/index.ts',
       role: 'entrypoint' as const,
@@ -231,7 +232,8 @@ describe('ResourceEntrySchema', () => {
 
   it('accepts optional ontology bindings on resource variants without changing top-level event emissions', () => {
     const ontology = {
-      implements: ['sys.lead-gen:action/company.scrape'],
+      actions: ['sys.lead-gen:action/company.scrape'],
+      primaryAction: 'sys.lead-gen:action/company.scrape',
       reads: ['sys.lead-gen:object/company'],
       writes: ['sys.lead-gen:object/company'],
       usesCatalogs: ['sys.lead-gen:catalog/build-template'],
@@ -268,7 +270,16 @@ describe('ResourceEntrySchema', () => {
   it('rejects malformed ontology binding ids', () => {
     expect(
       ResourceOntologyBindingSchema.safeParse({
-        implements: ['sys.lead-gen/action/company.scrape']
+        actions: ['sys.lead-gen/action/company.scrape']
+      }).success
+    ).toBe(false)
+  })
+
+  it('rejects primaryAction values outside actions', () => {
+    expect(
+      ResourceOntologyBindingSchema.safeParse({
+        actions: ['sys.lead-gen:action/company.scrape'],
+        primaryAction: 'sys.lead-gen:action/company.qualify'
       }).success
     ).toBe(false)
   })

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()
+  })
+})

package/src/organization-model/__tests__/graph.test.ts

@@ -115,15 +115,16 @@ describe('organization graph', () => {
     expect(() => OrganizationGraphEdgeKindSchema.parse('links')).not.toThrow()
     expect(() => OrganizationGraphEdgeKindSchema.parse('affects')).not.toThrow()
     expect(() => OrganizationGraphEdgeKindSchema.parse('emits')).not.toThrow()
-    expect(() => OrganizationGraphEdgeKindSchema.parse('originates_from')).not.toThrow()
-    expect(() => OrganizationGraphEdgeKindSchema.parse('triggers')).not.toThrow()
+    expect(() => OrganizationGraphEdgeKindSchema.parse('originates_from')).not.toThrow()
+    expect(() => OrganizationGraphEdgeKindSchema.parse('triggers')).not.toThrow()
+    expect(() => OrganizationGraphEdgeKindSchema.parse('approval')).not.toThrow()
     expect(() => OrganizationGraphNodeKindSchema.parse('surface')).not.toThrow()
     expect(() => OrganizationGraphNodeKindSchema.parse('customer-segment')).not.toThrow()
     expect(() => OrganizationGraphNodeKindSchema.parse('offering')).not.toThrow()
     expect(() => OrganizationGraphNodeKindSchema.parse('goal')).not.toThrow()
     expect(() => OrganizationGraphNodeKindSchema.parse('navigation-group')).not.toThrow()
     expect(() => OrganizationGraphNodeKindSchema.parse('ontology')).not.toThrow()
-    expect(() => OrganizationGraphEdgeKindSchema.parse('implements')).not.toThrow()
+    expect(() => OrganizationGraphEdgeKindSchema.parse('actions')).not.toThrow()
     expect(() => OrganizationGraphEdgeKindSchema.parse('reads')).not.toThrow()
     expect(() => OrganizationGraphEdgeKindSchema.parse('writes')).not.toThrow()
     expect(() => OrganizationGraphEdgeKindSchema.parse('uses_catalog')).not.toThrow()
@@ -431,7 +432,8 @@ describe('organization graph', () => {
           systemPath: 'test.bindings',
           status: 'active',
           ontology: {
-            implements: ['test.bindings:action/update-deal'],
+            actions: ['test.bindings:action/update-deal'],
+            primaryAction: 'test.bindings:action/update-deal',
             reads: ['test.bindings:object/deal'],
             writes: ['test.bindings:object/deal'],
             usesCatalogs: ['test.bindings:catalog/pipeline'],
@@ -445,7 +447,7 @@ describe('organization graph', () => {
     expect(
       graph.edges.find(
         (edge) =>
-          edge.kind === 'implements' &&
+          edge.kind === 'actions' &&
           edge.sourceId === 'resource:deal-workflow' &&
           edge.targetId === 'ontology:test.bindings:action/update-deal'
       )
@@ -483,8 +485,97 @@ describe('organization graph', () => {
       )
     ).toBeDefined()
   })
-
-  it('projects surface and navigation-group nodes from recursive sidebar leaves', () => {
+
+  it('projects topology relationships without collapsing ontology binding edges', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        'test.topology': {
+          id: 'test.topology',
+          order: 10,
+          label: 'Topology System',
+          enabled: true,
+          ontology: {
+            actionTypes: {
+              'test.topology:action/discover-email': {
+                id: 'test.topology:action/discover-email',
+                label: 'Discover Email'
+              }
+            }
+          }
+        }
+      },
+      resources: {
+        'email-discovery': {
+          id: 'email-discovery',
+          order: 10,
+          kind: 'workflow',
+          systemPath: 'test.topology',
+          status: 'active',
+          ontology: {
+            actions: ['test.topology:action/discover-email'],
+            primaryAction: 'test.topology:action/discover-email'
+          }
+        },
+        'email-verification': {
+          id: 'email-verification',
+          order: 20,
+          kind: 'workflow',
+          systemPath: 'test.topology',
+          status: 'active'
+        }
+      },
+      topology: {
+        version: 1,
+        relationships: {
+          'email-discovery-triggers-email-verification': {
+            from: { kind: 'resource', id: 'email-discovery' },
+            kind: 'triggers',
+            to: { kind: 'resource', id: 'email-verification' },
+            required: true
+          },
+          'email-verification-approval-human-review': {
+            from: { kind: 'resource', id: 'email-verification' },
+            kind: 'approval',
+            to: { kind: 'humanCheckpoint', id: 'email-review' }
+          }
+        }
+      }
+    })
+    const graph = buildOrganizationGraph({ organizationModel: model })
+
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'actions' &&
+          edge.sourceId === 'resource:email-discovery' &&
+          edge.targetId === 'ontology:test.topology:action/discover-email'
+      )
+    ).toBeDefined()
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'triggers' &&
+          edge.relationshipType === 'triggers' &&
+          edge.sourceId === 'resource:email-discovery' &&
+          edge.targetId === 'resource:email-verification'
+      )
+    ).toBeDefined()
+    expect(graph.nodes.find((node) => node.id === 'resource:email-review')).toMatchObject({
+      kind: 'resource',
+      resourceType: 'human_checkpoint'
+    })
+    expect(
+      graph.edges.find(
+        (edge) =>
+          edge.kind === 'approval' &&
+          edge.relationshipType === 'approval' &&
+          edge.sourceId === 'resource:email-verification' &&
+          edge.targetId === 'resource:email-review'
+      )
+    ).toBeDefined()
+  })
+
+  it('projects surface and navigation-group nodes from recursive sidebar leaves', () => {
     const model = resolveOrganizationModel({
       navigation: {
         sidebar: {

package/src/organization-model/__tests__/schema.test.ts

@@ -333,9 +333,17 @@ describe('ontology contract validation', () => {
     const compilation = compileOrganizationOntology(model)
 
     expect(compilation.diagnostics).toEqual([])
-    expect(compilation.ontology.objectTypes['dashboard:object/crm.deal']?.legacyEntityId).toBe('crm.deal')
+    expect(compilation.ontology.objectTypes['dashboard:object/crm.deal']).not.toHaveProperty('legacyEntityId')
+    expect(compilation.ontology.objectTypes['dashboard:object/crm.deal']?.origin).toMatchObject({
+      source: 'legacy.entities',
+      legacyId: 'crm.deal'
+    })
     expect(compilation.ontology.actionTypes['dashboard:action/send_reply']?.legacyActionId).toBe('send_reply')
-    expect(compilation.ontology.catalogTypes['dashboard:catalog/pipeline']?.legacyContentId).toBe('dashboard:pipeline')
+    expect(compilation.ontology.catalogTypes['dashboard:catalog/pipeline']).not.toHaveProperty('legacyContentId')
+    expect(compilation.ontology.catalogTypes['dashboard:catalog/pipeline']?.origin).toMatchObject({
+      source: 'legacy.system.content',
+      legacyId: 'dashboard:pipeline'
+    })
   })
 
   it('adds origin metadata to authored and projected compiled ontology records without mutating source', () => {
@@ -477,7 +485,8 @@ describe('ontology contract validation', () => {
           systemPath: 'dashboard',
           status: 'active',
           ontology: {
-            implements: ['dashboard:action/process-task'],
+            actions: ['dashboard:action/process-task'],
+            primaryAction: 'dashboard:action/process-task',
             reads: ['dashboard:object/task'],
             writes: ['dashboard:object/task'],
             usesCatalogs: ['dashboard:catalog/task-status'],
@@ -605,7 +614,8 @@ describe('ontology contract validation', () => {
           systemPath: 'dashboard',
           status: 'active',
           ontology: {
-            implements: ['dashboard:action/missing-task'],
+            actions: ['dashboard:action/missing-task'],
+            primaryAction: 'dashboard:action/missing-task',
             reads: ['dashboard:object/missing-task'],
             usesCatalogs: ['dashboard:catalog/missing-status'],
             emits: ['dashboard:event/missing-event']

package/src/organization-model/defaults.ts

@@ -17,6 +17,7 @@ import { DEFAULT_ORGANIZATION_MODEL_OFFERINGS } from './domains/offerings'
 import { DEFAULT_ORGANIZATION_MODEL_ROLES } from './domains/roles'
 import { DEFAULT_ORGANIZATION_MODEL_GOALS } from './domains/goals'
 import { DEFAULT_ORGANIZATION_MODEL_RESOURCES } from './domains/resources'
+import { DEFAULT_ORGANIZATION_MODEL_TOPOLOGY } from './domains/topology'
 import { CRM_ACTION_ENTRIES, DEFAULT_ORGANIZATION_MODEL_ACTIONS, LEAD_GEN_ACTION_ENTRIES } from './domains/actions'
 import { DEFAULT_ORGANIZATION_MODEL_ENTITIES as DEFAULT_ENTITIES } from './domains/entities'
 import { DEFAULT_ORGANIZATION_MODEL_POLICIES } from './domains/policies'
@@ -741,6 +742,7 @@ export const DEFAULT_ORGANIZATION_MODEL: OrganizationModel = {
   },
   ontology: DEFAULT_ONTOLOGY_SCOPE,
   resources: DEFAULT_ORGANIZATION_MODEL_RESOURCES,
+  topology: DEFAULT_ORGANIZATION_MODEL_TOPOLOGY,
   actions: DEFAULT_ORGANIZATION_MODEL_ACTIONS,
   entities: DEFAULT_ORGANIZATION_MODEL_ENTITIES,
   policies: DEFAULT_ORGANIZATION_MODEL_POLICIES,

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

@@ -1,5 +1,5 @@
 import { z } from 'zod'
-import { ModelIdSchema } from './shared'
+import { DescriptionSchema, LabelSchema, ModelIdSchema } from './shared'
 import { SystemPathSchema, SystemLifecycleSchema } from './systems'
 import { ActionInvocationSchema } from './actions'
 import { OntologyIdSchema } from '../ontology'
@@ -57,13 +57,35 @@ export const EventDescriptorSchema = EventEmissionDescriptorSchema.extend({
   ownerKind: z.enum(['resource', 'entity']).meta({ label: 'Owner kind' })
 })
 
-export const ResourceOntologyBindingSchema = z.object({
-  implements: z.array(OntologyIdSchema).optional(),
-  reads: z.array(OntologyIdSchema).optional(),
-  writes: z.array(OntologyIdSchema).optional(),
-  usesCatalogs: z.array(OntologyIdSchema).optional(),
-  emits: z.array(OntologyIdSchema).optional()
-})
+export const ResourceOntologyBindingSchema = z
+  .object({
+    actions: z.array(OntologyIdSchema).optional(),
+    primaryAction: OntologyIdSchema.optional(),
+    reads: z.array(OntologyIdSchema).optional(),
+    writes: z.array(OntologyIdSchema).optional(),
+    usesCatalogs: z.array(OntologyIdSchema).optional(),
+    emits: z.array(OntologyIdSchema).optional()
+  })
+  .superRefine((binding, ctx) => {
+    if (binding.primaryAction === undefined) return
+    if (binding.actions?.includes(binding.primaryAction)) return
+
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['primaryAction'],
+      message: 'Resource ontology primaryAction must be included in actions'
+    })
+  })
+
+type OntologyRefInput = string | { id: string }
+type ResourceOntologyBindingInput = {
+  actions?: OntologyRefInput[]
+  primaryAction?: OntologyRefInput
+  reads?: OntologyRefInput[]
+  writes?: OntologyRefInput[]
+  usesCatalogs?: OntologyRefInput[]
+  emits?: OntologyRefInput[]
+}
 
 export const CodeReferenceSchema = z.object({
   path: z
@@ -83,7 +105,11 @@ const ResourceEntryBaseSchema = z.object({
   /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
   order: z.number().default(0),
   /** Required single System membership — value is a dot-separated system path (e.g. "sales.lead-gen"). */
-  systemPath: SystemPathSchema.meta({ ref: 'system' }),
+  systemPath: SystemPathSchema.meta({ ref: 'system' }),
+  /** Executable display title owned by the OM Resource descriptor. */
+  title: LabelSchema.optional(),
+  /** Executable display description owned by the OM Resource descriptor. */
+  description: DescriptionSchema.optional(),
   /** Optional role responsible for maintaining this resource. */
   ownerRoleId: ModelIdSchema.meta({ ref: 'role' }).optional(),
   status: ResourceGovernanceStatusSchema,
@@ -97,12 +123,10 @@ const ResourceEntryBaseSchema = z.object({
   codeRefs: z.array(CodeReferenceSchema).default([])
 })
 
-export const WorkflowResourceEntrySchema = ResourceEntryBaseSchema.extend({
-  kind: z.literal('workflow'),
-  /** Mirrors WorkflowConfig.actionKey when the runtime workflow has one. */
-  actionKey: z.string().trim().min(1).max(255).optional(),
-  emits: z.array(EventEmissionDescriptorSchema).optional()
-})
+export const WorkflowResourceEntrySchema = ResourceEntryBaseSchema.extend({
+  kind: z.literal('workflow'),
+  emits: z.array(EventEmissionDescriptorSchema).optional()
+})
 
 export const AgentResourceEntrySchema = ResourceEntryBaseSchema.extend({
   kind: z.literal('agent'),
@@ -155,13 +179,32 @@ export function defineResource<const TResource extends ResourceEntry>(resource:
   return ResourceEntrySchema.parse(resource) as TResource
 }
 
-export function defineResources<const TResources extends Record<string, ResourceEntry>>(
-  resources: TResources
-): TResources {
+export function defineResources<const TResources extends Record<string, ResourceEntry>>(
+  resources: TResources
+): TResources {
   return Object.fromEntries(
     Object.entries(resources).map(([key, resource]) => [key, ResourceEntrySchema.parse(resource)])
-  ) as TResources
-}
+  ) as TResources
+}
+
+function ontologyIdFrom(input: OntologyRefInput): string {
+  return typeof input === 'string' ? input : input.id
+}
+
+function ontologyIdArrayFrom(input: OntologyRefInput[] | undefined): string[] | undefined {
+  return input?.map(ontologyIdFrom)
+}
+
+export function defineResourceOntology(input: ResourceOntologyBindingInput): ResourceOntologyBinding {
+  return ResourceOntologyBindingSchema.parse({
+    actions: ontologyIdArrayFrom(input.actions),
+    primaryAction: input.primaryAction === undefined ? undefined : ontologyIdFrom(input.primaryAction),
+    reads: ontologyIdArrayFrom(input.reads),
+    writes: ontologyIdArrayFrom(input.writes),
+    usesCatalogs: ontologyIdArrayFrom(input.usesCatalogs),
+    emits: ontologyIdArrayFrom(input.emits)
+  })
+}
 
 export type ResourceId = z.infer<typeof ResourceIdSchema>
 export type ResourceKind = z.infer<typeof ResourceKindSchema>