@elevasis/core 0.22.0 → 0.24.0

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

@@ -271,9 +271,10 @@ describe('resolveOrganizationModel — identity domain integration', () => {
     const model = resolveOrganizationModel({
       identity: { mission: 'Isolated change.' }
     })
-    // navigation, features, statuses etc. must still be present
+    // Phase 4 (D1, D8): model.navigation and model.statuses removed from top-level OM.
+    // Verify other sibling domains still present instead.
+    expect(model.systems).toBeDefined()
+    expect(model.knowledge).toBeDefined()
     expect(model.navigation).toBeDefined()
-    expect(model.features).toBeDefined()
-    expect(model.statuses).toBeDefined()
   })
 })

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

@@ -1,212 +1,268 @@
 import { describe, expect, it } from 'vitest'
 import {
-  CORE_PLACEMENT_VALUES,
-  NavigationGroupSchema,
+  getSortedSidebarEntries,
   OrganizationModelNavigationSchema,
+  SidebarNodeSchema,
+  SurfaceDefinitionSchema,
   SurfaceTypeSchema
 } from '../../domains/navigation'
 import { ResourceMappingSchema } from '../../domains/shared'
+import { OrganizationModelSchema } from '../../schema'
 
-// ---------------------------------------------------------------------------
-// Group 1: Default placement values parse (core baseline)
-// ---------------------------------------------------------------------------
-
-describe('NavigationGroupSchema — core placement values', () => {
-  it.each(CORE_PLACEMENT_VALUES)('"%s" is accepted as a placement value', (placement) => {
-    const result = NavigationGroupSchema.safeParse({
-      id: 'test-group',
-      label: 'Test Group',
-      placement,
-      surfaceIds: []
-    })
-    expect(result.success).toBe(true)
-  })
-})
+function makeMinimalSystems() {
+  return {
+    dashboard: {
+      id: 'dashboard',
+      order: 10,
+      label: 'Dashboard',
+      enabled: true,
+      lifecycle: 'active' as const,
+      path: '/'
+    },
+    sales: {
+      id: 'sales',
+      order: 20,
+      label: 'Sales',
+      enabled: true,
+      lifecycle: 'active' as const,
+      path: '/sales'
+    }
+  }
+}
 
-// ---------------------------------------------------------------------------
-// Group 2: Extension placement values parse (open string pattern)
-// ---------------------------------------------------------------------------
-
-describe('NavigationGroupSchema — extension placement values', () => {
-  it('accepts "pinned" as an extension placement value', () => {
-    const result = NavigationGroupSchema.safeParse({
-      id: 'pinned-group',
-      label: 'Pinned',
-      placement: 'pinned',
-      surfaceIds: []
-    })
-    expect(result.success).toBe(true)
-  })
+function makeMinimalModel(overrides: Record<string, unknown> = {}) {
+  return {
+    version: 1,
+    branding: { organizationName: 'Test', productName: 'Test OS', shortName: 'Test' },
+    systems: makeMinimalSystems(),
+    entities: {},
+    actions: {},
+    ...overrides
+  }
+}
 
-  it('accepts "spotlight" as an extension placement value', () => {
-    const result = NavigationGroupSchema.safeParse({
-      id: 'spotlight-group',
-      label: 'Spotlight',
-      placement: 'spotlight',
-      surfaceIds: []
-    })
-    expect(result.success).toBe(true)
-  })
+function getIssueMessages(data: unknown): string[] {
+  const result = OrganizationModelSchema.safeParse(data)
+  if (result.success) return []
+  return result.error.issues.map((issue) => issue.message)
+}
 
-  it('accepts "contextual" as an extension placement value', () => {
-    const result = NavigationGroupSchema.safeParse({
-      id: 'ctx-group',
-      label: 'Contextual',
-      placement: 'contextual',
-      surfaceIds: []
-    })
-    expect(result.success).toBe(true)
+describe('SurfaceTypeSchema - closed enum regression guard', () => {
+  const validSurfaceTypes = ['page', 'dashboard', 'graph', 'detail', 'list', 'settings'] as const
+
+  it.each(validSurfaceTypes)('"%s" is a valid surfaceType', (surfaceType) => {
+    expect(SurfaceTypeSchema.safeParse(surfaceType).success).toBe(true)
   })
 
-  it('trims whitespace from extension placement values', () => {
-    const result = NavigationGroupSchema.safeParse({
-      id: 'trim-group',
-      label: 'Trimmed',
-      placement: '  pinned  ',
-      surfaceIds: []
-    })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.placement).toBe('pinned')
-    }
+  it('rejects an unknown surfaceType value', () => {
+    expect(SurfaceTypeSchema.safeParse('spotlight').success).toBe(false)
   })
 })
 
-// ---------------------------------------------------------------------------
-// Group 3: Placement rejection cases (non-string, empty)
-// ---------------------------------------------------------------------------
-
-describe('NavigationGroupSchema — placement rejection cases', () => {
-  it('rejects a numeric placement value', () => {
-    const result = NavigationGroupSchema.safeParse({
-      id: 'num-group',
-      label: 'Numeric',
-      placement: 42,
-      surfaceIds: []
+describe('ResourceMappingSchema resourceType - closed enum regression guard', () => {
+  it('rejects an unknown resourceType value', () => {
+    const result = ResourceMappingSchema.safeParse({
+      id: 'rm-ext',
+      label: 'Extended Resource',
+      resourceId: 'res-ext',
+      resourceType: 'custom-handler',
+      systemIds: [],
+      entityIds: [],
+      surfaceIds: [],
+      actionIds: []
     })
+
     expect(result.success).toBe(false)
   })
+})
 
-  it('rejects null as a placement value', () => {
-    const result = NavigationGroupSchema.safeParse({
-      id: 'null-group',
-      label: 'Null',
-      placement: null,
-      surfaceIds: []
-    })
-    expect(result.success).toBe(false)
+describe('OrganizationModelNavigationSchema', () => {
+  it('defaults sidebar sections to empty records', () => {
+    const result = OrganizationModelNavigationSchema.parse({})
+
+    expect(result.sidebar.primary).toEqual({})
+    expect(result.sidebar.bottom).toEqual({})
   })
 
-  it('rejects an empty string placement (min length 1 after trim)', () => {
-    const result = NavigationGroupSchema.safeParse({
-      id: 'empty-group',
-      label: 'Empty',
-      placement: '   ',
-      surfaceIds: []
+  it('accepts a nested sidebar group with routeable surface leaves', () => {
+    const result = SidebarNodeSchema.safeParse({
+      type: 'group',
+      label: 'Business',
+      order: 20,
+      children: {
+        sales: {
+          type: 'surface',
+          label: 'Sales',
+          path: '/sales',
+          surfaceType: 'page',
+          order: 10,
+          targets: { systems: ['sales'] }
+        }
+      }
     })
-    expect(result.success).toBe(false)
+
+    expect(result.success).toBe(true)
   })
 
-  it('rejects a missing placement field', () => {
-    const result = NavigationGroupSchema.safeParse({
-      id: 'no-placement-group',
-      label: 'No Placement',
-      surfaceIds: []
+  it('sorts record-shaped sidebar entries by order, then id', () => {
+    const entries = getSortedSidebarEntries({
+      zed: { type: 'surface', label: 'Zed', path: '/zed', surfaceType: 'page', order: 20 },
+      alpha: { type: 'surface', label: 'Alpha', path: '/alpha', surfaceType: 'page', order: 10 },
+      beta: { type: 'surface', label: 'Beta', path: '/beta', surfaceType: 'page', order: 10 }
     })
-    expect(result.success).toBe(false)
+
+    expect(entries.map(([id]) => id)).toEqual(['alpha', 'beta', 'zed'])
   })
 })
 
-// ---------------------------------------------------------------------------
-// Group 4: surfaceType remains CLOSED (closed enum regression guard)
-// ---------------------------------------------------------------------------
-
-describe('SurfaceTypeSchema — closed enum regression guard', () => {
-  const validSurfaceTypes = ['page', 'dashboard', 'graph', 'detail', 'list', 'settings'] as const
+describe('OrganizationModelSchema - navigation.sidebar contract', () => {
+  it('accepts authored primary and bottom sidebar sections', () => {
+    const result = OrganizationModelSchema.safeParse(
+      makeMinimalModel({
+        navigation: {
+          sidebar: {
+            primary: {
+              dashboard: {
+                type: 'surface',
+                label: 'Dashboard',
+                path: '/',
+                surfaceType: 'dashboard',
+                order: 10,
+                targets: { systems: ['dashboard'] }
+              },
+              business: {
+                type: 'group',
+                label: 'Business',
+                order: 20,
+                children: {
+                  sales: {
+                    type: 'surface',
+                    label: 'Sales',
+                    path: '/sales',
+                    surfaceType: 'page',
+                    order: 10,
+                    targets: { systems: ['sales'] }
+                  }
+                }
+              }
+            },
+            bottom: {
+              settings: {
+                type: 'surface',
+                label: 'Settings',
+                path: '/settings/account',
+                surfaceType: 'settings',
+                order: 10
+              }
+            }
+          }
+        }
+      })
+    )
 
-  it.each(validSurfaceTypes)('"%s" is a valid surfaceType', (surfaceType) => {
-    const result = SurfaceTypeSchema.safeParse(surfaceType)
     expect(result.success).toBe(true)
   })
 
-  it('rejects an unknown surfaceType value', () => {
-    const result = SurfaceTypeSchema.safeParse('spotlight')
-    expect(result.success).toBe(false)
-  })
+  it('navigation.sidebar defaults when omitted', () => {
+    const result = OrganizationModelSchema.safeParse(makeMinimalModel())
 
-  it('rejects a numeric surfaceType value', () => {
-    const result = SurfaceTypeSchema.safeParse(1)
-    expect(result.success).toBe(false)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.navigation.sidebar.primary).toEqual({})
+      expect(result.data.navigation.sidebar.bottom).toEqual({})
+      expect('surfaces' in result.data).toBe(false)
+      expect('navigationGroups' in result.data).toBe(false)
+    }
   })
-})
 
-// ---------------------------------------------------------------------------
-// Group 5: resourceType remains CLOSED (closed enum regression guard)
-// ---------------------------------------------------------------------------
+  it('rejects duplicate sidebar node ids across sections and children', () => {
+    const messages = getIssueMessages(
+      makeMinimalModel({
+        navigation: {
+          sidebar: {
+            primary: {
+              sales: {
+                type: 'surface',
+                label: 'Sales',
+                path: '/sales',
+                surfaceType: 'page'
+              }
+            },
+            bottom: {
+              sales: {
+                type: 'surface',
+                label: 'Sales Duplicate',
+                path: '/settings/sales',
+                surfaceType: 'settings'
+              }
+            }
+          }
+        }
+      })
+    )
 
-describe('ResourceMappingSchema resourceType — closed enum regression guard', () => {
-  const validResourceTypes = ['workflow', 'agent', 'trigger', 'integration', 'external', 'human_checkpoint'] as const
+    expect(messages.some((message) => message.includes('duplicates another sidebar node'))).toBe(true)
+  })
 
-  it.each(validResourceTypes)('"%s" is a valid resourceType', (resourceType) => {
-    const result = ResourceMappingSchema.safeParse({
-      id: 'rm-test',
-      label: 'Test Resource',
-      resourceId: 'res-1',
-      resourceType,
-      featureIds: [],
-      entityIds: [],
-      surfaceIds: [],
-      capabilityIds: []
-    })
-    expect(result.success).toBe(true)
+  it('rejects duplicate routeable surface paths', () => {
+    const messages = getIssueMessages(
+      makeMinimalModel({
+        navigation: {
+          sidebar: {
+            primary: {
+              first: {
+                type: 'surface',
+                label: 'First',
+                path: '/sales',
+                surfaceType: 'page'
+              },
+              second: {
+                type: 'surface',
+                label: 'Second',
+                path: '/sales/',
+                surfaceType: 'page'
+              }
+            }
+          }
+        }
+      })
+    )
+
+    expect(messages.some((message) => message.includes('duplicates surface "first"'))).toBe(true)
   })
 
-  it('rejects an unknown resourceType value', () => {
-    const result = ResourceMappingSchema.safeParse({
-      id: 'rm-ext',
-      label: 'Extended Resource',
-      resourceId: 'res-ext',
-      resourceType: 'custom-handler',
-      featureIds: [],
-      entityIds: [],
-      surfaceIds: [],
-      capabilityIds: []
-    })
-    expect(result.success).toBe(false)
+  it('rejects surface leaves targeting unknown systems', () => {
+    const messages = getIssueMessages(
+      makeMinimalModel({
+        navigation: {
+          sidebar: {
+            primary: {
+              missing: {
+                type: 'surface',
+                label: 'Missing',
+                path: '/missing',
+                surfaceType: 'page',
+                targets: { systems: ['missing-system'] }
+              }
+            }
+          }
+        }
+      })
+    )
+
+    expect(messages.some((message) => message.includes('references unknown system "missing-system"'))).toBe(true)
   })
 })
 
-// ---------------------------------------------------------------------------
-// Group 6: OrganizationModelNavigationSchema — extension placement in a full group
-// ---------------------------------------------------------------------------
-
-describe('OrganizationModelNavigationSchema — extension placement roundtrip', () => {
-  it('parses a navigation model where a group uses an extension placement value', () => {
-    const result = OrganizationModelNavigationSchema.safeParse({
-      surfaces: [
-        {
-          id: 'home',
-          label: 'Home',
-          path: '/home',
-          surfaceType: 'page',
-          featureIds: [],
-          entityIds: [],
-          resourceIds: [],
-          capabilityIds: []
-        }
-      ],
-      groups: [
-        {
-          id: 'pinned-group',
-          label: 'Pinned',
-          placement: 'pinned',
-          surfaceIds: ['home']
-        }
-      ]
+describe('SurfaceDefinitionSchema', () => {
+  it('keeps derived surface DTO validation available for projections', () => {
+    const result = SurfaceDefinitionSchema.safeParse({
+      id: 'minimal-surface',
+      label: 'Minimal',
+      path: '/minimal',
+      surfaceType: 'page'
     })
+
     expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.groups[0].placement).toBe('pinned')
-    }
   })
 })