@elevasis/core 0.1.0 → 0.2.0

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

@@ -80,9 +80,621 @@ describe('organization-graph', () => {
     )
   })
 
+  describe('titleCase fallback for feature labels', () => {
+    it('uses titleCase of the feature key when no label is configured', () => {
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          branding: { organizationName: 'Acme', productName: 'Acme OS', shortName: 'Acme' }
+        })
+      )
+
+      const graph = buildOrganizationGraph({ organizationModel: model })
+
+      // All feature keys are single lowercase words with no label overrides by default.
+      // titleCase('acquisition') => 'Acquisition', etc.
+      const featureKeys = ['acquisition', 'delivery', 'operations', 'monitoring', 'settings', 'seo', 'calibration']
+      for (const key of featureKeys) {
+        const node = graph.nodes.find((n) => n.id === `feature:${key}`)
+        expect(node, `feature node for '${key}' should exist`).toBeDefined()
+        // No label override is set, so the label must be the titleCase of the key.
+        const expected = key.charAt(0).toUpperCase() + key.slice(1)
+        expect(node?.label).toBe(expected)
+      }
+    })
+
+    it('uses the explicit label from features.labels when one is configured', () => {
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          branding: { organizationName: 'Acme', productName: 'Acme OS', shortName: 'Acme' },
+          features: {
+            labels: { acquisition: 'Lead Generation' }
+          }
+        })
+      )
+
+      const graph = buildOrganizationGraph({ organizationModel: model })
+
+      const node = graph.nodes.find((n) => n.id === 'feature:acquisition')
+      expect(node?.label).toBe('Lead Generation')
+
+      // Other features without explicit labels still fall back to titleCase.
+      const deliveryNode = graph.nodes.find((n) => n.id === 'feature:delivery')
+      expect(deliveryNode?.label).toBe('Delivery')
+    })
+  })
+
+  describe('resource node upsert merging', () => {
+    it('keeps resourceMappings label and merges description from commandViewData', () => {
+      // Surface and domain are kept minimal (no cross-references) so that
+      // OrganizationModelSchema bidirectional integrity checks pass. The test
+      // is only exercising resource node merging, not surface/domain linkage.
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          domains: [
+            {
+              id: 'operations',
+              label: 'Operations',
+              color: 'violet',
+              entityIds: [],
+              surfaceIds: ['operations.command-view'],
+              resourceIds: ['workflow-order'],
+              capabilityIds: []
+            }
+          ],
+          navigation: {
+            defaultSurfaceId: 'operations.command-view',
+            surfaces: [
+              {
+                id: 'operations.command-view',
+                label: 'Command View',
+                path: '/operations/command-view',
+                surfaceType: 'graph',
+                featureKey: 'operations',
+                domainIds: ['operations'],
+                entityIds: [],
+                resourceIds: ['workflow-order'],
+                capabilityIds: []
+              }
+            ],
+            groups: [
+              {
+                id: 'primary-operations',
+                label: 'Operations',
+                placement: 'primary',
+                surfaceIds: ['operations.command-view']
+              }
+            ]
+          },
+          resourceMappings: [
+            {
+              id: 'workflow-order-model',
+              label: 'Order Workflow',
+              resourceId: 'workflow-order',
+              resourceType: 'workflow',
+              domainIds: ['operations'],
+              entityIds: [],
+              surfaceIds: ['operations.command-view'],
+              capabilityIds: []
+            }
+          ]
+        })
+      )
+
+      const graph = buildOrganizationGraph({
+        organizationModel: model,
+        commandViewData: {
+          workflows: [
+            {
+              resourceId: 'workflow-order',
+              name: 'Order Workflow Runtime',
+              description: 'Runtime description from commandViewData',
+              version: '1.0.0',
+              type: 'workflow',
+              status: 'prod',
+              domains: ['operations'],
+              stepCount: 2,
+              entryPoint: 'start'
+            }
+          ],
+          agents: [],
+          triggers: [],
+          integrations: [],
+          externalResources: [],
+          humanCheckpoints: [],
+          edges: []
+        }
+      })
+
+      const resourceNodes = graph.nodes.filter((n) => n.id === 'resource:workflow-order')
+      expect(resourceNodes).toHaveLength(1)
+
+      const node = resourceNodes[0]
+      // Label from resourceMappings is a real label (not just the sourceId), so it is preserved.
+      expect(node.label).toBe('Order Workflow')
+      // Description was absent in resourceMappings, so it is filled in from commandViewData.
+      expect(node.description).toBe('Runtime description from commandViewData')
+    })
+
+    it('preserves existing non-default label even when commandViewData provides a different name', () => {
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          domains: [
+            {
+              id: 'ops',
+              label: 'Ops',
+              color: 'blue',
+              entityIds: [],
+              surfaceIds: ['ops.view'],
+              resourceIds: ['res-a'],
+              capabilityIds: []
+            }
+          ],
+          navigation: {
+            defaultSurfaceId: 'ops.view',
+            surfaces: [
+              {
+                id: 'ops.view',
+                label: 'Ops View',
+                path: '/ops/view',
+                surfaceType: 'graph',
+                featureKey: 'operations',
+                domainIds: ['ops'],
+                entityIds: [],
+                resourceIds: ['res-a'],
+                capabilityIds: []
+              }
+            ],
+            groups: [{ id: 'g', label: 'Ops', placement: 'primary', surfaceIds: ['ops.view'] }]
+          },
+          resourceMappings: [
+            {
+              id: 'res-a-model',
+              label: 'My Custom Label',
+              resourceId: 'res-a',
+              resourceType: 'workflow',
+              domainIds: ['ops'],
+              entityIds: [],
+              surfaceIds: ['ops.view'],
+              capabilityIds: []
+            }
+          ]
+        })
+      )
+
+      const graph = buildOrganizationGraph({
+        organizationModel: model,
+        commandViewData: {
+          workflows: [
+            {
+              resourceId: 'res-a',
+              name: 'Runtime Name Should Not Override',
+              description: 'desc',
+              version: '1.0.0',
+              type: 'workflow',
+              status: 'prod',
+              domains: ['ops'],
+              stepCount: 1,
+              entryPoint: 'start'
+            }
+          ],
+          agents: [],
+          triggers: [],
+          integrations: [],
+          externalResources: [],
+          humanCheckpoints: [],
+          edges: []
+        }
+      })
+
+      const node = graph.nodes.find((n) => n.id === 'resource:res-a')
+      expect(node?.label).toBe('My Custom Label')
+    })
+  })
+
+  describe('de-duplication of graph elements', () => {
+    it('creates only one domain node when multiple surfaces reference the same domain', () => {
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          domains: [
+            {
+              id: 'crm',
+              label: 'CRM',
+              color: 'blue',
+              entityIds: [],
+              surfaceIds: ['crm.pipeline', 'crm.accounts'],
+              resourceIds: [],
+              capabilityIds: []
+            }
+          ],
+          navigation: {
+            defaultSurfaceId: 'crm.pipeline',
+            surfaces: [
+              {
+                id: 'crm.pipeline',
+                label: 'Pipeline',
+                path: '/crm/pipeline',
+                surfaceType: 'graph',
+                featureKey: 'acquisition',
+                domainIds: ['crm'],
+                entityIds: [],
+                resourceIds: [],
+                capabilityIds: []
+              },
+              {
+                id: 'crm.accounts',
+                label: 'Accounts',
+                path: '/crm/accounts',
+                surfaceType: 'list',
+                featureKey: 'acquisition',
+                domainIds: ['crm'],
+                entityIds: [],
+                resourceIds: [],
+                capabilityIds: []
+              }
+            ],
+            groups: [{ id: 'g', label: 'CRM', placement: 'primary', surfaceIds: ['crm.pipeline', 'crm.accounts'] }]
+          }
+        })
+      )
+
+      const graph = buildOrganizationGraph({ organizationModel: model })
+
+      const domainNodes = graph.nodes.filter((n) => n.id === 'domain:crm')
+      expect(domainNodes).toHaveLength(1)
+    })
+
+    it('creates only one entity node when the same entity appears in both a domain and a surface', () => {
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          domains: [
+            {
+              id: 'crm',
+              label: 'CRM',
+              color: 'blue',
+              entityIds: ['crm.deal'],
+              surfaceIds: ['crm.pipeline'],
+              resourceIds: [],
+              capabilityIds: []
+            }
+          ],
+          navigation: {
+            defaultSurfaceId: 'crm.pipeline',
+            surfaces: [
+              {
+                id: 'crm.pipeline',
+                label: 'Pipeline',
+                path: '/crm/pipeline',
+                surfaceType: 'graph',
+                featureKey: 'acquisition',
+                domainIds: ['crm'],
+                entityIds: ['crm.deal'],
+                resourceIds: [],
+                capabilityIds: []
+              }
+            ],
+            groups: [{ id: 'g', label: 'CRM', placement: 'primary', surfaceIds: ['crm.pipeline'] }]
+          }
+        })
+      )
+
+      const graph = buildOrganizationGraph({ organizationModel: model })
+
+      const entityNodes = graph.nodes.filter((n) => n.id === 'entity:crm.deal')
+      expect(entityNodes).toHaveLength(1)
+    })
+
+    it('creates only one resource node when the same resource appears in resourceMappings and commandViewData', () => {
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          domains: [
+            {
+              id: 'ops',
+              label: 'Ops',
+              color: 'violet',
+              entityIds: [],
+              surfaceIds: ['ops.view'],
+              resourceIds: ['wf-shared'],
+              capabilityIds: []
+            }
+          ],
+          navigation: {
+            defaultSurfaceId: 'ops.view',
+            surfaces: [
+              {
+                id: 'ops.view',
+                label: 'Ops View',
+                path: '/ops/view',
+                surfaceType: 'graph',
+                featureKey: 'operations',
+                domainIds: ['ops'],
+                entityIds: [],
+                resourceIds: ['wf-shared'],
+                capabilityIds: []
+              }
+            ],
+            groups: [{ id: 'g', label: 'Ops', placement: 'primary', surfaceIds: ['ops.view'] }]
+          },
+          resourceMappings: [
+            {
+              id: 'wf-shared-model',
+              label: 'Shared Workflow',
+              resourceId: 'wf-shared',
+              resourceType: 'workflow',
+              domainIds: ['ops'],
+              entityIds: [],
+              surfaceIds: ['ops.view'],
+              capabilityIds: []
+            }
+          ]
+        })
+      )
+
+      const graph = buildOrganizationGraph({
+        organizationModel: model,
+        commandViewData: {
+          workflows: [
+            {
+              resourceId: 'wf-shared',
+              name: 'Shared Workflow Runtime',
+              description: 'desc',
+              version: '1.0.0',
+              type: 'workflow',
+              status: 'prod',
+              domains: ['ops'],
+              stepCount: 1,
+              entryPoint: 'start'
+            }
+          ],
+          agents: [],
+          triggers: [],
+          integrations: [],
+          externalResources: [],
+          humanCheckpoints: [],
+          edges: []
+        }
+      })
+
+      const resourceNodes = graph.nodes.filter((n) => n.id === 'resource:wf-shared')
+      expect(resourceNodes).toHaveLength(1)
+    })
+  })
+
+  describe('commandViewData edge relationships', () => {
+    it('creates a stub resource node with label === resourceId for edges referencing unknown resources', () => {
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          domains: [
+            {
+              id: 'ops',
+              label: 'Ops',
+              color: 'violet',
+              entityIds: [],
+              surfaceIds: [],
+              resourceIds: [],
+              capabilityIds: []
+            }
+          ],
+          navigation: {
+            defaultSurfaceId: 'ops.view',
+            surfaces: [
+              {
+                id: 'ops.view',
+                label: 'Ops View',
+                path: '/ops/view',
+                surfaceType: 'graph',
+                featureKey: 'operations',
+                domainIds: [],
+                entityIds: [],
+                resourceIds: [],
+                capabilityIds: []
+              }
+            ],
+            groups: [{ id: 'g', label: 'Ops', placement: 'primary', surfaceIds: ['ops.view'] }]
+          }
+        })
+      )
+
+      // Both source and target in the edge are NOT listed in any workflow/agent/etc. array.
+      const graph = buildOrganizationGraph({
+        organizationModel: model,
+        commandViewData: {
+          workflows: [],
+          agents: [],
+          triggers: [],
+          integrations: [],
+          externalResources: [],
+          humanCheckpoints: [],
+          edges: [
+            {
+              id: 'edge-unknown',
+              source: 'unknown-source',
+              target: 'unknown-target',
+              relationship: 'triggers'
+            }
+          ]
+        }
+      })
+
+      const sourceNode = graph.nodes.find((n) => n.id === 'resource:unknown-source')
+      expect(sourceNode).toBeDefined()
+      expect(sourceNode?.label).toBe('unknown-source')
+      expect(sourceNode?.sourceId).toBe('unknown-source')
+
+      const targetNode = graph.nodes.find((n) => n.id === 'resource:unknown-target')
+      expect(targetNode).toBeDefined()
+      expect(targetNode?.label).toBe('unknown-target')
+      expect(targetNode?.sourceId).toBe('unknown-target')
+    })
+
+    it('normalizes humanCheckpoints type to human_checkpoint on resource nodes', () => {
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          domains: [
+            {
+              id: 'ops',
+              label: 'Ops',
+              color: 'violet',
+              entityIds: [],
+              surfaceIds: [],
+              resourceIds: [],
+              capabilityIds: []
+            }
+          ],
+          navigation: {
+            defaultSurfaceId: 'ops.view',
+            surfaces: [
+              {
+                id: 'ops.view',
+                label: 'Ops View',
+                path: '/ops/view',
+                surfaceType: 'graph',
+                featureKey: 'operations',
+                domainIds: [],
+                entityIds: [],
+                resourceIds: [],
+                capabilityIds: []
+              }
+            ],
+            groups: [{ id: 'g', label: 'Ops', placement: 'primary', surfaceIds: ['ops.view'] }]
+          }
+        })
+      )
+
+      const graph = buildOrganizationGraph({
+        organizationModel: model,
+        commandViewData: {
+          workflows: [],
+          agents: [],
+          triggers: [],
+          integrations: [],
+          externalResources: [],
+          humanCheckpoints: [
+            {
+              resourceId: 'approval-step',
+              name: 'Approval Step',
+              description: 'Human review gate',
+              version: '1.0.0',
+              type: 'human',
+              status: 'prod',
+              domains: ['ops']
+            }
+          ],
+          edges: []
+        }
+      })
+
+      const node = graph.nodes.find((n) => n.id === 'resource:approval-step')
+      expect(node).toBeDefined()
+      expect(node?.resourceType).toBe('human_checkpoint')
+    })
+
+    it('creates a references edge with label and relationshipType for commandViewData edges', () => {
+      const model = resolveOrganizationModel(
+        defineOrganizationModel({
+          domains: [
+            {
+              id: 'ops',
+              label: 'Ops',
+              color: 'violet',
+              entityIds: [],
+              surfaceIds: [],
+              resourceIds: [],
+              capabilityIds: []
+            }
+          ],
+          navigation: {
+            defaultSurfaceId: 'ops.view',
+            surfaces: [
+              {
+                id: 'ops.view',
+                label: 'Ops View',
+                path: '/ops/view',
+                surfaceType: 'graph',
+                featureKey: 'operations',
+                domainIds: [],
+                entityIds: [],
+                resourceIds: [],
+                capabilityIds: []
+              }
+            ],
+            groups: [{ id: 'g', label: 'Ops', placement: 'primary', surfaceIds: ['ops.view'] }]
+          }
+        })
+      )
+
+      const graph = buildOrganizationGraph({
+        organizationModel: model,
+        commandViewData: {
+          workflows: [],
+          agents: [],
+          triggers: [],
+          integrations: [],
+          externalResources: [],
+          humanCheckpoints: [],
+          edges: [
+            {
+              id: 'edge-triggers',
+              source: 'svc-a',
+              target: 'svc-b',
+              relationship: 'triggers'
+            }
+          ]
+        }
+      })
+
+      expect(graph.edges).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            kind: 'references',
+            sourceId: 'resource:svc-a',
+            targetId: 'resource:svc-b',
+            label: 'triggers',
+            relationshipType: 'triggers'
+          })
+        ])
+      )
+    })
+  })
+
   it('bridges command view topology into resource nodes and labeled relationship edges', () => {
     const model = resolveOrganizationModel(
       defineOrganizationModel({
+        domains: [
+          {
+            id: 'operations',
+            label: 'Operations',
+            description: 'Operational resources, topology, and orchestration visibility',
+            color: 'violet',
+            entityIds: [],
+            surfaceIds: ['operations.command-view'],
+            resourceIds: ['workflow-order'],
+            capabilityIds: ['operations.command-view']
+          }
+        ],
+        navigation: {
+          defaultSurfaceId: 'operations.command-view',
+          surfaces: [
+            {
+              id: 'operations.command-view',
+              label: 'Command View',
+              path: '/operations/command-view',
+              surfaceType: 'graph',
+              featureKey: 'operations',
+              domainIds: ['operations'],
+              entityIds: [],
+              resourceIds: ['workflow-order'],
+              capabilityIds: ['operations.command-view']
+            }
+          ],
+          groups: [
+            {
+              id: 'primary-operations',
+              label: 'Operations',
+              placement: 'primary',
+              surfaceIds: ['operations.command-view']
+            }
+          ]
+        },
         resourceMappings: [
           {
             id: 'workflow-order-model',