@elevasis/core 0.22.0 → 0.23.0

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

@@ -1,105 +1,77 @@
-import { describe, expect, it } from 'vitest'
-import { createFoundationOrganizationModel } from '../foundation'
-
-describe('createFoundationOrganizationModel', () => {
-  it('builds the foundation model from a branding-only override', () => {
-    const result = createFoundationOrganizationModel({
-      branding: { organizationName: 'Acme', productName: 'Acme OS', shortName: 'Acme' }
-    })
-
-    expect(result.canonical.branding.organizationName).toBe('Acme')
-    expect(result.homeLabel).toBe('Dashboard')
-    expect(result.model.navigation.defaultSurfaceId).toBe('operations')
-
-    const surfaces = result.model.navigation.surfaces
-    expect(surfaces.find((s) => s.id === 'crm')).toBeDefined()
-    expect(surfaces.find((s) => s.id === 'lead-gen')).toBeDefined()
-    expect(surfaces.find((s) => s.id === 'projects')).toBeDefined()
-    expect(surfaces.find((s) => s.id === 'operations')).toBeDefined()
-    expect(surfaces.find((s) => s.id === 'settings')).toBeDefined()
-
-    expect(result.quickAccessSurfaceIds).toContain('operations')
-    expect(result.quickAccessSurfaceIds).toContain('projects')
-    expect(result.quickAccessSurfaceIds).toContain('lead-gen')
-    expect(result.quickAccessSurfaceIds).toContain('crm')
-  })
-
-  it('passes deeper overrides through to the canonical model', () => {
-    const result = createFoundationOrganizationModel({
-      branding: { organizationName: 'Acme', productName: 'Acme OS', shortName: 'Acme' },
-      sales: {
-        pipelines: [
-          {
-            id: 'custom-pipeline',
-            label: 'Custom Pipeline',
-            description: 'A custom pipeline',
-            entityId: 'crm.deal',
-            stages: [
-              {
-                id: 'stage-1',
-                label: 'Stage 1',
-                color: 'blue',
-                order: 0,
-                semanticClass: 'open' as const,
-                surfaceIds: ['crm.pipeline'],
-                resourceIds: []
-              }
-            ]
-          }
-        ]
-      }
-    })
-
-    expect(result.canonical.sales.pipelines).toHaveLength(1)
-    expect(result.canonical.sales.pipelines[0]?.id).toBe('custom-pipeline')
-  })
-
-  it('exposes a working getOrganizationSurface lookup', () => {
-    const result = createFoundationOrganizationModel({
-      branding: { organizationName: 'Acme', productName: 'Acme OS', shortName: 'Acme' }
-    })
-
-    const crmSurface = result.getOrganizationSurface('crm')
-    expect(crmSurface).toBeDefined()
-    expect(crmSurface?.id).toBe('crm')
-    expect(crmSurface?.icon).toBe('feature.crm')
+import { describe, expect, it } from 'vitest'
+import { createFoundationOrganizationModel } from '../foundation'
+
+describe('createFoundationOrganizationModel', () => {
+  it('builds the foundation model from derived sidebar navigation', () => {
+    const result = createFoundationOrganizationModel({
+      branding: { organizationName: 'Acme', productName: 'Acme OS', shortName: 'Acme' }
+    })
+
+    expect(result.canonical.branding.organizationName).toBe('Acme')
+    expect(result.homeLabel).toBe('Dashboard')
+    expect(result.model.navigation.defaultSurfaceId).toBe('dashboard')
+
+    const surfaces = result.model.navigation.surfaces
+    expect(surfaces.find((s) => s.id === 'dashboard')).toMatchObject({ path: '/', surfaceType: 'dashboard' })
+    expect(surfaces.find((s) => s.id === 'sales')).toBeDefined()
+    expect(surfaces.find((s) => s.id === 'clients')).toMatchObject({ path: '/clients' })
+    expect(surfaces.find((s) => s.id === 'projects')).toBeDefined()
+    expect(surfaces.find((s) => s.id === 'operations-overview')).toBeDefined()
+    expect(surfaces.find((s) => s.id === 'settings-account')).toBeDefined()
+
+    expect(result.quickAccessSurfaceIds).toContain('sales')
+    expect(result.quickAccessSurfaceIds).toContain('clients')
+    expect(result.quickAccessSurfaceIds).toContain('projects')
+    expect(result.quickAccessSurfaceIds).toContain('operations-overview')
+  })
+
+  it.skip('passes deeper overrides through to the canonical model (deferred - Phase 4: sales domain removed)', () => {
+    // Previously tested: result.canonical.sales.pipelines.
+    // Re-enable with a content-node based pipeline override test if needed.
+  })
+
+  it('exposes a working getOrganizationSurface lookup', () => {
+    const result = createFoundationOrganizationModel({
+      branding: { organizationName: 'Acme', productName: 'Acme OS', shortName: 'Acme' }
+    })
+
+    const clientsSurface = result.getOrganizationSurface('clients')
+    expect(clientsSurface).toBeDefined()
+    expect(clientsSurface?.id).toBe('clients')
+    expect(clientsSurface?.path).toBe('/clients')
 
     expect(result.getOrganizationSurface('nonexistent')).toBeUndefined()
   })
-
-  it('throws when a required core surface is missing', () => {
-    const override = {
-      features: [
-        {
-          id: 'crm',
-          label: 'CRM',
-          description: 'CRM workspace',
-          enabled: true,
-          color: 'blue',
-          entityIds: [],
-          surfaceIds: ['custom.home'],
-          resourceIds: [],
-          capabilityIds: []
-        }
-      ],
-      navigation: {
-        defaultSurfaceId: 'custom.home',
-        surfaces: [
-          {
-            id: 'custom.home',
-            label: 'Home',
-            path: '/home',
-            surfaceType: 'page' as const,
-            featureIds: ['crm'],
-            entityIds: [],
-            resourceIds: [],
-            capabilityIds: []
-          }
-        ],
-        groups: [{ id: 'primary', label: 'Primary', placement: 'primary', surfaceIds: ['custom.home'] }]
-      }
-    }
-
-    expect(() => createFoundationOrganizationModel(override)).toThrow(/Missing organization surface/)
-  })
-})
+
+  it('does not require hardcoded system-backed foundation surfaces', () => {
+    const result = createFoundationOrganizationModel({
+      navigation: {
+        sidebar: {
+          primary: {
+            dashboard: {
+              type: 'surface',
+              label: 'Home',
+              path: '/',
+              surfaceType: 'dashboard',
+              order: 10,
+              targets: { systems: ['dashboard'] }
+            },
+            custom: {
+              type: 'surface',
+              label: 'Custom',
+              path: '/custom',
+              surfaceType: 'page',
+              order: 20,
+              targets: { systems: [] }
+            }
+          },
+          bottom: {}
+        }
+      }
+    })
+
+    expect(result.model.navigation.defaultSurfaceId).toBe('dashboard')
+    expect(result.homeLabel).toBe('Home')
+    expect(result.getOrganizationSurface('custom')).toMatchObject({ label: 'Custom', path: '/custom' })
+  })
+})

package/src/organization-model/__tests__/get-resources-for-system.test.ts

@@ -0,0 +1,144 @@
+/**
+ * Unit tests for getResourcesForSystem helper.
+ *
+ * Coverage:
+ * - Empty model (no resources)
+ * - Single leaf resource, exact match
+ * - includeDescendants: true returns descendants
+ * - Deep nesting (three levels)
+ * - Segment-boundary safety: 'sales' must NOT match 'salesforce.foo'
+ * - Root path with includeDescendants: false
+ * - Root path with includeDescendants: true
+ * - Mixed resources, only matching ones returned
+ */
+import { describe, it, expect } from 'vitest'
+import { getResourcesForSystem } from '../helpers'
+import type { OrganizationModel } from '../types'
+import type { ResourceEntry } from '../domains/resources'
+
+// ---------------------------------------------------------------------------
+// Minimal fixture builder
+// ---------------------------------------------------------------------------
+
+function makeModel(resources: Record<string, ResourceEntry>): OrganizationModel {
+  return {
+    systems: {},
+    resources,
+    roles: {},
+    goals: {},
+    knowledge: {},
+    actions: {},
+    entities: {},
+    policies: {},
+    navigation: { sidebar: { primary: {}, bottom: {} } }
+  } as unknown as OrganizationModel
+}
+
+function makeWorkflow(id: string, systemPath: string): ResourceEntry {
+  return {
+    id,
+    order: 10,
+    kind: 'workflow',
+    systemPath,
+    status: 'active'
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('getResourcesForSystem', () => {
+  it('returns empty array when model has no resources', () => {
+    const model = makeModel({})
+    expect(getResourcesForSystem(model, 'sales')).toEqual([])
+  })
+
+  it('returns empty array when no resources match the path', () => {
+    const model = makeModel({
+      'wf-a': makeWorkflow('wf-a', 'marketing')
+    })
+    expect(getResourcesForSystem(model, 'sales')).toEqual([])
+  })
+
+  it('returns a single resource with exact match', () => {
+    const r = makeWorkflow('wf-a', 'sales')
+    const model = makeModel({ 'wf-a': r })
+    const result = getResourcesForSystem(model, 'sales')
+    expect(result).toHaveLength(1)
+    expect(result[0].id).toBe('wf-a')
+  })
+
+  it('does NOT return descendants when includeDescendants is false (default)', () => {
+    const model = makeModel({
+      'wf-a': makeWorkflow('wf-a', 'sales'),
+      'wf-b': makeWorkflow('wf-b', 'sales.crm'),
+      'wf-c': makeWorkflow('wf-c', 'sales.lead-gen')
+    })
+    const result = getResourcesForSystem(model, 'sales')
+    expect(result).toHaveLength(1)
+    expect(result[0].id).toBe('wf-a')
+  })
+
+  it('returns exact match AND descendants when includeDescendants is true', () => {
+    const model = makeModel({
+      'wf-a': makeWorkflow('wf-a', 'sales'),
+      'wf-b': makeWorkflow('wf-b', 'sales.crm'),
+      'wf-c': makeWorkflow('wf-c', 'sales.lead-gen'),
+      'wf-d': makeWorkflow('wf-d', 'marketing')
+    })
+    const result = getResourcesForSystem(model, 'sales', { includeDescendants: true })
+    const ids = result.map((r) => r.id).sort()
+    expect(ids).toEqual(['wf-a', 'wf-b', 'wf-c'])
+  })
+
+  it('matches three-level deep descendants', () => {
+    const model = makeModel({
+      'wf-a': makeWorkflow('wf-a', 'sales.crm.dispositions'),
+      'wf-b': makeWorkflow('wf-b', 'sales.crm'),
+      'wf-c': makeWorkflow('wf-c', 'sales')
+    })
+    const result = getResourcesForSystem(model, 'sales', { includeDescendants: true })
+    expect(result).toHaveLength(3)
+  })
+
+  it('segment-boundary: "sales" does NOT match "salesforce.foo"', () => {
+    const model = makeModel({
+      'wf-a': makeWorkflow('wf-a', 'salesforce.foo'),
+      'wf-b': makeWorkflow('wf-b', 'salesforce'),
+      'wf-c': makeWorkflow('wf-c', 'sales')
+    })
+    const result = getResourcesForSystem(model, 'sales', { includeDescendants: true })
+    // Only exact 'sales' match — 'salesforce' and 'salesforce.foo' must NOT appear
+    expect(result).toHaveLength(1)
+    expect(result[0].id).toBe('wf-c')
+  })
+
+  it('segment-boundary: "sys" does NOT match "sys2.foo" or "system.bar"', () => {
+    const model = makeModel({
+      'wf-a': makeWorkflow('wf-a', 'sys'),
+      'wf-b': makeWorkflow('wf-b', 'sys.platform'),
+      'wf-c': makeWorkflow('wf-c', 'sys2.foo'),
+      'wf-d': makeWorkflow('wf-d', 'system.bar')
+    })
+    const result = getResourcesForSystem(model, 'sys', { includeDescendants: true })
+    const ids = result.map((r) => r.id).sort()
+    expect(ids).toEqual(['wf-a', 'wf-b'])
+  })
+
+  it('root path with includeDescendants false returns only exact root resources', () => {
+    const model = makeModel({
+      'wf-a': makeWorkflow('wf-a', 'sys'),
+      'wf-b': makeWorkflow('wf-b', 'sys.platform'),
+      'wf-c': makeWorkflow('wf-c', 'sys.diagnostic')
+    })
+    const result = getResourcesForSystem(model, 'sys')
+    expect(result).toHaveLength(1)
+    expect(result[0].id).toBe('wf-a')
+  })
+
+  it('handles undefined resources gracefully via nullish coalescing', () => {
+    const model = { systems: {}, resources: undefined } as unknown as OrganizationModel
+    expect(getResourcesForSystem(model, 'sales')).toEqual([])
+  })
+})