@elevasis/core 0.19.0 → 0.21.0

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

@@ -14,6 +14,20 @@ function makeFeature(id: string, path = `/${id.replaceAll('.', '/')}`) {
   }
 }
 
+function makeSurface(id: string, featureId?: string, featureIds: string[] = []) {
+  return {
+    id,
+    label: id,
+    path: `/${id.replaceAll('.', '/')}`,
+    surfaceType: 'page' as const,
+    featureId,
+    featureIds,
+    entityIds: [],
+    resourceIds: [],
+    capabilityIds: []
+  }
+}
+
 function makeMinimalModel(features: unknown[] = []) {
   return {
     version: 1 as const,
@@ -48,6 +62,22 @@ describe('flat feature tree validation', () => {
     expect(messages.some((message) => message.includes('Feature id "sales" must be unique'))).toBe(true)
   })
 
+  it('rejects duplicate effective feature paths when explicit and default paths collide', () => {
+    const messages = getIssueMessages(
+      makeMinimalModel([
+        { id: 'sales', label: 'Sales', enabled: true },
+        makeFeature('sales.crm', '/sales/lead-gen'),
+        { id: 'sales.lead-gen', label: 'Lead Gen', enabled: true }
+      ])
+    )
+
+    expect(
+      messages.some((message) =>
+        message.includes('Feature "sales.lead-gen" effective path "/sales/lead-gen" duplicates feature "sales.crm"')
+      )
+    ).toBe(true)
+  })
+
   it('rejects a dotted child when its immediate parent is missing', () => {
     const messages = getIssueMessages(makeMinimalModel([makeFeature('sales.crm.pipeline')]))
 
@@ -80,4 +110,96 @@ describe('flat feature tree validation', () => {
     expect(model.navigation.groups).toEqual([])
     expect('resourceMappings' in model).toBe(false)
   })
+
+  it('rejects an unknown navigation default surface when surfaces are explicitly empty', () => {
+    const messages = getIssueMessages({
+      ...makeMinimalModel([makeFeature('dashboard', '/')]),
+      navigation: {
+        defaultSurfaceId: 'missing.surface',
+        surfaces: [],
+        groups: []
+      }
+    })
+
+    expect(
+      messages.some((message) =>
+        message.includes('Navigation defaultSurfaceId references unknown surface "missing.surface"')
+      )
+    ).toBe(true)
+  })
+
+  it('rejects navigation group surfaceIds that reference missing surfaces', () => {
+    const messages = getIssueMessages({
+      ...makeMinimalModel([makeFeature('dashboard', '/')]),
+      navigation: {
+        surfaces: [makeSurface('dashboard.home', 'dashboard')],
+        groups: [
+          {
+            id: 'primary',
+            label: 'Primary',
+            placement: 'primary',
+            surfaceIds: ['missing.surface']
+          }
+        ]
+      }
+    })
+
+    expect(
+      messages.some((message) =>
+        message.includes('Navigation group "primary" references unknown surface "missing.surface"')
+      )
+    ).toBe(true)
+  })
+
+  it('rejects navigation surface featureId references to missing features', () => {
+    const messages = getIssueMessages({
+      ...makeMinimalModel([makeFeature('dashboard', '/')]),
+      navigation: {
+        surfaces: [makeSurface('dashboard.home', 'missing.feature')],
+        groups: []
+      }
+    })
+
+    expect(
+      messages.some((message) =>
+        message.includes('Navigation surface "dashboard.home" references unknown feature "missing.feature"')
+      )
+    ).toBe(true)
+  })
+
+  it('rejects navigation surface featureIds references to missing features', () => {
+    const messages = getIssueMessages({
+      ...makeMinimalModel([makeFeature('dashboard', '/')]),
+      navigation: {
+        surfaces: [makeSurface('dashboard.home', 'dashboard', ['dashboard', 'missing.feature'])],
+        groups: []
+      }
+    })
+
+    expect(
+      messages.some((message) =>
+        message.includes('Navigation surface "dashboard.home" references unknown feature "missing.feature"')
+      )
+    ).toBe(true)
+  })
+
+  it('allows legacy navigation feature aliases when canonical features exist', () => {
+    const result = OrganizationModelSchema.safeParse({
+      ...makeMinimalModel([
+        { id: 'sales', label: 'Sales', enabled: true },
+        makeFeature('sales.crm', '/sales/crm/pipeline'),
+        makeFeature('sales.lead-gen', '/lead-gen/lists')
+      ]),
+      navigation: {
+        defaultSurfaceId: 'crm.pipeline',
+        surfaces: [
+          makeSurface('crm.pipeline', 'crm', ['crm']),
+          makeSurface('lead-gen.lists', 'lead-gen', ['lead-gen'])
+        ],
+        groups: []
+      }
+    })
+
+    expect(result.success).toBe(true)
+  })
 })

package/src/organization-model/__tests__/surface-projection.test.ts

@@ -0,0 +1,174 @@
+import { describe, expect, it } from 'vitest'
+import { DEFAULT_ORGANIZATION_MODEL } from '../defaults'
+import {
+  projectOrganizationSurfaces,
+  validateOrganizationSurfaceProjection
+} from '../surface-projection'
+import type { OrganizationModel, OrganizationModelFeature, OrganizationModelSurface } from '../types'
+
+function makeFeature(
+  id: string,
+  overrides: Partial<OrganizationModelFeature> = {}
+): OrganizationModelFeature {
+  return {
+    id,
+    label: id,
+    enabled: true,
+    ...overrides
+  }
+}
+
+function makeSurface(
+  id: string,
+  overrides: Partial<OrganizationModelSurface> = {}
+): OrganizationModelSurface {
+  return {
+    id,
+    label: id,
+    path: `/${id.replaceAll('.', '/')}`,
+    surfaceType: 'page',
+    enabled: true,
+    featureIds: [],
+    entityIds: [],
+    resourceIds: [],
+    capabilityIds: [],
+    ...overrides
+  }
+}
+
+function makeModel(
+  features: OrganizationModelFeature[],
+  surfaces: OrganizationModelSurface[],
+  navigation: Partial<OrganizationModel['navigation']> = {}
+): OrganizationModel {
+  return {
+    ...DEFAULT_ORGANIZATION_MODEL,
+    features,
+    navigation: {
+      surfaces,
+      groups: [],
+      ...navigation
+    }
+  }
+}
+
+describe('projectOrganizationSurfaces', () => {
+  it('projects navigation surfaces into data-only DTOs with inherited flags', () => {
+    const model = makeModel(
+      [
+        makeFeature('sales', { requiresAdmin: true }),
+        makeFeature('sales.crm', { devOnly: true })
+      ],
+      [
+        makeSurface('crm.pipeline', {
+          label: 'Pipeline',
+          path: '/crm/pipeline',
+          surfaceType: 'graph',
+          featureId: 'sales.crm',
+          featureIds: ['sales.crm'],
+          entityIds: ['crm.deal'],
+          resourceIds: ['workflow.crm-sync'],
+          capabilityIds: ['crm.pipeline.manage']
+        })
+      ]
+    )
+
+    expect(projectOrganizationSurfaces(model)).toEqual([
+      {
+        id: 'crm.pipeline',
+        label: 'Pipeline',
+        path: '/crm/pipeline',
+        surfaceType: 'graph',
+        featureId: 'sales.crm',
+        featureIds: ['sales.crm'],
+        entityIds: ['crm.deal'],
+        resourceIds: ['workflow.crm-sync'],
+        capabilityIds: ['crm.pipeline.manage'],
+        enabled: true,
+        devOnly: true,
+        requiresAdmin: true
+      }
+    ])
+  })
+
+  it('canonicalizes legacy feature aliases', () => {
+    const model = makeModel(
+      [
+        makeFeature('sales'),
+        makeFeature('sales.crm'),
+        makeFeature('sales.lead-gen'),
+        makeFeature('monitoring'),
+        makeFeature('monitoring.submitted-requests')
+      ],
+      [
+        makeSurface('legacy.sales', {
+          featureId: 'crm',
+          featureIds: ['crm', 'lead-gen', 'submitted-requests']
+        })
+      ]
+    )
+
+    expect(projectOrganizationSurfaces(model)[0]).toMatchObject({
+      featureId: 'sales.crm',
+      featureIds: ['sales.crm', 'sales.lead-gen', 'monitoring.submitted-requests']
+    })
+  })
+
+  it('disables projected surfaces when feature lineage is disabled', () => {
+    const model = makeModel(
+      [
+        makeFeature('sales', { enabled: false }),
+        makeFeature('sales.crm')
+      ],
+      [
+        makeSurface('crm.pipeline', {
+          enabled: true,
+          featureId: 'sales.crm',
+          featureIds: ['sales.crm']
+        })
+      ]
+    )
+
+    expect(projectOrganizationSurfaces(model)[0].enabled).toBe(false)
+  })
+})
+
+describe('validateOrganizationSurfaceProjection', () => {
+  it('returns issue codes for duplicate and unknown surface references', () => {
+    const model = makeModel(
+      [makeFeature('sales'), makeFeature('sales.crm')],
+      [
+        makeSurface('crm.pipeline', {
+          path: '/crm/pipeline',
+          featureId: 'sales.crm',
+          featureIds: ['sales.crm']
+        }),
+        makeSurface('crm.pipeline', {
+          path: '/crm/pipeline/',
+          featureId: 'missing.primary',
+          featureIds: ['missing.related']
+        })
+      ],
+      {
+        defaultSurfaceId: 'missing.default',
+        groups: [
+          {
+            id: 'primary',
+            label: 'Primary',
+            placement: 'primary',
+            surfaceIds: ['missing.group']
+          }
+        ]
+      }
+    )
+
+    expect(validateOrganizationSurfaceProjection(model).map((issue) => issue.code)).toEqual([
+      'duplicate-surface-id',
+      'duplicate-surface-path',
+      'unknown-surface-feature',
+      'unknown-surface-feature-reference',
+      'unknown-default-surface',
+      'unknown-group-surface'
+    ])
+  })
+})