@elevasis/core 0.22.0 → 0.23.0

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

@@ -1,32 +1,59 @@
 import { describe, expect, it } from 'vitest'
-import { defineOrganizationModel, resolveOrganizationModel } from '../resolve'
+import { defineOrganizationModel, resolveOrganizationModel, resolveOrganizationModelWithResources } from '../resolve'
 
 describe('organization-model resolve', () => {
-  it('resolves the flat feature defaults', () => {
+  it('resolves the system defaults', () => {
     const model = resolveOrganizationModel()
 
     expect(model.version).toBe(1)
-    expect(model.features.find((feature) => feature.id === 'dashboard')?.path).toBe('/')
-    expect(model.features.find((feature) => feature.id === 'sales')?.path).toBe('/sales')
-    expect(model.features.find((feature) => feature.id === 'sales.crm')?.path).toBe('/crm')
-    expect(model.features.find((feature) => feature.id === 'admin')?.requiresAdmin).toBe(true)
-    expect(model.features.find((feature) => feature.id === 'archive')?.devOnly).toBe(true)
+    expect('surfaces' in model).toBe(false)
+    expect('navigationGroups' in model).toBe(false)
+    expect(model.systems['dashboard']?.path).toBe('/')
+    expect(model.systems['sales']?.path).toBe('/sales')
+    expect(model.systems['sales.crm']?.path).toBe('/crm')
+    expect(model.systems['admin']?.requiresAdmin).toBe(true)
+    expect(model.systems['archive']?.devOnly).toBe(true)
   })
 
-  it('replaces arrays when an override supplies a complete feature slice', () => {
+  it('resolves authored sidebar navigation with Dashboard above Business and /clients as the client route', () => {
+    const model = resolveOrganizationModel()
+    const primaryEntries = Object.entries(model.navigation.sidebar.primary).sort(
+      ([leftId, left], [rightId, right]) =>
+        (left.order ?? Number.MAX_SAFE_INTEGER) - (right.order ?? Number.MAX_SAFE_INTEGER) ||
+        leftId.localeCompare(rightId)
+    )
+
+    expect(primaryEntries[0]?.[0]).toBe('dashboard')
+    expect(primaryEntries[1]?.[0]).toBe('business')
+
+    const business = model.navigation.sidebar.primary.business
+    expect(business?.type).toBe('group')
+    if (business?.type === 'group') {
+      expect(business.children.clients).toMatchObject({
+        type: 'surface',
+        path: '/clients',
+        targets: { systems: ['clients'] }
+      })
+    }
+  })
+
+  it('adds tenant systems additively to the merged record', () => {
+    const baseSize = Object.keys(resolveOrganizationModel().systems).length
+
     const model = resolveOrganizationModel({
-      features: [
-        {
+      systems: {
+        custom: {
           id: 'custom',
+          order: 10,
           label: 'Custom',
           enabled: true,
           path: '/custom'
         }
-      ]
+      }
     })
 
-    expect(model.features).toHaveLength(1)
-    expect(model.features[0]?.id).toBe('custom')
+    expect(Object.keys(model.systems)).toHaveLength(baseSize + 1)
+    expect(model.systems['custom']?.id).toBe('custom')
   })
 
   it('preserves sibling fields when overriding a nested property', () => {
@@ -38,18 +65,24 @@ describe('organization-model resolve', () => {
 
     expect(model.branding.organizationName).toBe('OverriddenOrg')
     expect(model.branding.productName).toBe('Elevasis')
-    expect(model.features.length).toBeGreaterThan(0)
+    expect(Object.keys(model.systems).length).toBeGreaterThan(0)
   })
 
-  it('throws on duplicate feature ids in the merged result', () => {
-    expect(() =>
-      resolveOrganizationModel({
-        features: [
-          { id: 'custom', label: 'Custom A', enabled: true, path: '/custom-a' },
-          { id: 'custom', label: 'Custom B', enabled: true, path: '/custom-b' }
-        ]
-      })
-    ).toThrow()
+  it('overrides an existing system by id when the same key is supplied', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        dashboard: {
+          id: 'dashboard',
+          order: 10,
+          label: 'Renamed Dashboard',
+          enabled: true,
+          path: '/dashboard-overridden'
+        }
+      }
+    })
+
+    expect(model.systems['dashboard']?.label).toBe('Renamed Dashboard')
+    expect(model.systems['dashboard']?.path).toBe('/dashboard-overridden')
   })
 
   it('returns defineOrganizationModel input unchanged', () => {
@@ -57,3 +90,121 @@ describe('organization-model resolve', () => {
     expect(defineOrganizationModel(input)).toBe(input)
   })
 })
+
+describe('resolveOrganizationModelWithResources', () => {
+  it('populates resources on the matching system entry', () => {
+    const resolved = resolveOrganizationModelWithResources({
+      systems: {
+        sys: {
+          id: 'sys',
+          order: 900,
+          label: 'Sys',
+          enabled: true
+        },
+        'sys.crm': {
+          id: 'sys.crm',
+          order: 910,
+          label: 'CRM',
+          enabled: true
+        }
+      },
+      resources: {
+        'crm-workflow': {
+          id: 'crm-workflow',
+          kind: 'workflow',
+          systemPath: 'sys.crm',
+          status: 'active',
+          order: 10
+        }
+      }
+    })
+
+    const crmSystem = resolved.systems['sys.crm']
+    expect(crmSystem?.resources).toHaveLength(1)
+    expect(crmSystem?.resources?.[0]?.id).toBe('crm-workflow')
+  })
+
+  it('leaves systems without resources with no resources property', () => {
+    const resolved = resolveOrganizationModelWithResources({
+      systems: {
+        sys: {
+          id: 'sys',
+          order: 900,
+          label: 'Sys',
+          enabled: true
+        }
+      }
+    })
+
+    // sys has no resources attached — property should be absent (undefined)
+    expect(resolved.systems['sys']?.resources).toBeUndefined()
+  })
+
+  it('does not include descendant resources in the direct system entry', () => {
+    const resolved = resolveOrganizationModelWithResources({
+      systems: {
+        sys: {
+          id: 'sys',
+          order: 900,
+          label: 'Sys',
+          enabled: true
+        },
+        'sys.crm': {
+          id: 'sys.crm',
+          order: 910,
+          label: 'CRM',
+          enabled: true
+        }
+      },
+      resources: {
+        'crm-workflow': {
+          id: 'crm-workflow',
+          kind: 'workflow',
+          systemPath: 'sys.crm',
+          status: 'active',
+          order: 10
+        }
+      }
+    })
+
+    // 'sys' parent should NOT pick up the child's resource
+    expect(resolved.systems['sys']?.resources).toBeUndefined()
+  })
+
+  it('groups multiple resources under the correct system', () => {
+    const resolved = resolveOrganizationModelWithResources({
+      systems: {
+        sys: {
+          id: 'sys',
+          order: 900,
+          label: 'Sys',
+          enabled: true
+        },
+        'sys.crm': {
+          id: 'sys.crm',
+          order: 910,
+          label: 'CRM',
+          enabled: true
+        }
+      },
+      resources: {
+        'crm-workflow-a': {
+          id: 'crm-workflow-a',
+          kind: 'workflow',
+          systemPath: 'sys.crm',
+          status: 'active',
+          order: 10
+        },
+        'crm-workflow-b': {
+          id: 'crm-workflow-b',
+          kind: 'workflow',
+          systemPath: 'sys.crm',
+          status: 'active',
+          order: 20
+        }
+      }
+    })
+
+    expect(resolved.systems['sys.crm']?.resources).toHaveLength(2)
+  })
+})