@elevasis/core 0.22.0 → 0.24.0

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

@@ -15,19 +15,20 @@ describe('ProductSchema — positive parse', () => {
   it('accepts a fully-populated product', () => {
     const result = ProductSchema.safeParse({
       id: 'product-starter-plan',
+      order: 10,
       name: 'Starter Plan',
       description: 'Full-service automation for small teams.',
       pricingModel: 'subscription',
       price: 299,
       currency: 'USD',
       targetSegmentIds: ['seg-smb'],
-      deliveryFeatureId: 'crm'
+      deliveryFeatureId: 'sales.crm'
     })
     expect(result.success).toBe(true)
   })
 
-  it('accepts a minimal product — only id required', () => {
-    const result = ProductSchema.safeParse({ id: 'product-minimal' })
+  it('accepts a minimal product — only id and order required', () => {
+    const result = ProductSchema.safeParse({ id: 'product-minimal', order: 10 })
     expect(result.success).toBe(true)
     if (result.success) {
       expect(result.data.id).toBe('product-minimal')
@@ -44,6 +45,7 @@ describe('ProductSchema — positive parse', () => {
   it('trims whitespace from id and name', () => {
     const result = ProductSchema.safeParse({
       id: '  product-trim  ',
+      order: 10,
       name: '  Trimmed Name  '
     })
     expect(result.success).toBe(true)
@@ -56,6 +58,7 @@ describe('ProductSchema — positive parse', () => {
   it('accepts price of 0 (free tier)', () => {
     const result = ProductSchema.safeParse({
       id: 'product-free',
+      order: 10,
       pricingModel: 'subscription',
       price: 0
     })
@@ -68,7 +71,7 @@ describe('ProductSchema — positive parse', () => {
   it('accepts all four pricing model values', () => {
     const models = ['one-time', 'subscription', 'usage-based', 'custom'] as const
     for (const pricingModel of models) {
-      const result = ProductSchema.safeParse({ id: `product-${pricingModel}`, pricingModel })
+      const result = ProductSchema.safeParse({ id: `product-${pricingModel}`, order: 10, pricingModel })
       expect(result.success).toBe(true)
     }
   })
@@ -80,7 +83,7 @@ describe('ProductSchema — positive parse', () => {
 
 describe('ProductSchema — default values', () => {
   it('pricingModel defaults to "custom"', () => {
-    const result = ProductSchema.safeParse({ id: 'product-defaults' })
+    const result = ProductSchema.safeParse({ id: 'product-defaults', order: 10 })
     expect(result.success).toBe(true)
     if (result.success) {
       expect(result.data.pricingModel).toBe('custom')
@@ -88,7 +91,7 @@ describe('ProductSchema — default values', () => {
   })
 
   it('price defaults to 0', () => {
-    const result = ProductSchema.safeParse({ id: 'product-defaults' })
+    const result = ProductSchema.safeParse({ id: 'product-defaults', order: 10 })
     expect(result.success).toBe(true)
     if (result.success) {
       expect(result.data.price).toBe(0)
@@ -96,7 +99,7 @@ describe('ProductSchema — default values', () => {
   })
 
   it('currency defaults to "USD"', () => {
-    const result = ProductSchema.safeParse({ id: 'product-defaults' })
+    const result = ProductSchema.safeParse({ id: 'product-defaults', order: 10 })
     expect(result.success).toBe(true)
     if (result.success) {
       expect(result.data.currency).toBe('USD')
@@ -104,7 +107,7 @@ describe('ProductSchema — default values', () => {
   })
 
   it('targetSegmentIds defaults to empty array', () => {
-    const result = ProductSchema.safeParse({ id: 'product-defaults' })
+    const result = ProductSchema.safeParse({ id: 'product-defaults', order: 10 })
     expect(result.success).toBe(true)
     if (result.success) {
       expect(result.data.targetSegmentIds).toEqual([])
@@ -112,7 +115,7 @@ describe('ProductSchema — default values', () => {
   })
 
   it('deliveryFeatureId defaults to undefined (field is optional)', () => {
-    const result = ProductSchema.safeParse({ id: 'product-defaults' })
+    const result = ProductSchema.safeParse({ id: 'product-defaults', order: 10 })
     expect(result.success).toBe(true)
     if (result.success) {
       expect(result.data.deliveryFeatureId).toBeUndefined()
@@ -126,37 +129,37 @@ describe('ProductSchema — default values', () => {
 
 describe('ProductSchema — negative parse', () => {
   it('rejects missing id', () => {
-    const result = ProductSchema.safeParse({ name: 'No ID Product' })
+    const result = ProductSchema.safeParse({ order: 10, name: 'No ID Product' })
     expect(result.success).toBe(false)
   })
 
   it('rejects empty string id', () => {
-    const result = ProductSchema.safeParse({ id: '' })
+    const result = ProductSchema.safeParse({ id: '', order: 10 })
     expect(result.success).toBe(false)
   })
 
   it('rejects whitespace-only id (trims to empty string)', () => {
-    const result = ProductSchema.safeParse({ id: '   ' })
+    const result = ProductSchema.safeParse({ id: '   ', order: 10 })
     expect(result.success).toBe(false)
   })
 
   it('rejects an unknown pricingModel value', () => {
-    const result = ProductSchema.safeParse({ id: 'product-bad-model', pricingModel: 'freemium' })
+    const result = ProductSchema.safeParse({ id: 'product-bad-model', order: 10, pricingModel: 'freemium' })
     expect(result.success).toBe(false)
   })
 
   it('rejects price below 0', () => {
-    const result = ProductSchema.safeParse({ id: 'product-negative-price', price: -1 })
+    const result = ProductSchema.safeParse({ id: 'product-negative-price', order: 10, price: -1 })
     expect(result.success).toBe(false)
   })
 
   it('rejects price as a string', () => {
-    const result = ProductSchema.safeParse({ id: 'product-string-price', price: '299' })
+    const result = ProductSchema.safeParse({ id: 'product-string-price', order: 10, price: '299' })
     expect(result.success).toBe(false)
   })
 
   it('rejects targetSegmentIds as a non-array value', () => {
-    const result = ProductSchema.safeParse({ id: 'product-bad-segments', targetSegmentIds: 'seg-a' })
+    const result = ProductSchema.safeParse({ id: 'product-bad-segments', order: 10, targetSegmentIds: 'seg-a' })
     expect(result.success).toBe(false)
   })
 })
@@ -189,34 +192,34 @@ describe('PricingModelSchema — enum', () => {
 // ---------------------------------------------------------------------------
 
 describe('OfferingsDomainSchema — structural', () => {
-  it('accepts an empty products array', () => {
-    const result = OfferingsDomainSchema.safeParse({ products: [] })
+  it('accepts an empty products record', () => {
+    const result = OfferingsDomainSchema.safeParse({})
     expect(result.success).toBe(true)
   })
 
-  it('defaults products to empty array when key is omitted', () => {
+  it('defaults products to empty record when omitted', () => {
     const result = OfferingsDomainSchema.safeParse({})
     expect(result.success).toBe(true)
     if (result.success) {
-      expect(result.data.products).toEqual([])
+      expect(result.data).toEqual({})
     }
   })
 
   it('accepts multiple valid products', () => {
     const result = OfferingsDomainSchema.safeParse({
-      products: [
-        { id: 'product-a', name: 'Product A', pricingModel: 'subscription' },
-        { id: 'product-b', name: 'Product B', pricingModel: 'one-time', price: 999 }
-      ]
+      'product-a': { id: 'product-a', order: 10, name: 'Product A', pricingModel: 'subscription' },
+      'product-b': { id: 'product-b', order: 20, name: 'Product B', pricingModel: 'one-time', price: 999 }
     })
     expect(result.success).toBe(true)
     if (result.success) {
-      expect(result.data.products).toHaveLength(2)
+      expect(Object.keys(result.data)).toHaveLength(2)
     }
   })
 
-  it('rejects products as a non-array value', () => {
-    const result = OfferingsDomainSchema.safeParse({ products: 'not an array' })
+  it('rejects a record where entry id does not match map key', () => {
+    const result = OfferingsDomainSchema.safeParse({
+      'product-a': { id: 'product-b', order: 10, name: 'Mismatched' }
+    })
     expect(result.success).toBe(false)
   })
 
@@ -238,17 +241,16 @@ describe('resolveOrganizationModel — offerings cross-ref (targetSegmentIds)',
     expect(() =>
       resolveOrganizationModel({
         customers: {
-          segments: [{ id: 'seg-agencies', name: 'SMB Agencies' }]
+          'seg-agencies': { id: 'seg-agencies', order: 10, name: 'SMB Agencies' }
         },
         offerings: {
-          products: [
-            {
-              id: 'product-starter',
-              name: 'Starter Plan',
-              pricingModel: 'subscription',
-              targetSegmentIds: ['seg-agencies']
-            }
-          ]
+          'product-starter': {
+            id: 'product-starter',
+            order: 10,
+            name: 'Starter Plan',
+            pricingModel: 'subscription',
+            targetSegmentIds: ['seg-agencies']
+          }
         }
       })
     ).not.toThrow()
@@ -257,14 +259,13 @@ describe('resolveOrganizationModel — offerings cross-ref (targetSegmentIds)',
   it('throws when targetSegmentIds references a non-existent segment', () => {
     expect(() =>
       resolveOrganizationModel({
-        customers: { segments: [] },
+        customers: {},
         offerings: {
-          products: [
-            {
-              id: 'product-bad-ref',
-              targetSegmentIds: ['nonexistent-segment']
-            }
-          ]
+          'product-bad-ref': {
+            id: 'product-bad-ref',
+            order: 10,
+            targetSegmentIds: ['nonexistent-segment']
+          }
         }
       })
     ).toThrow()
@@ -274,14 +275,13 @@ describe('resolveOrganizationModel — offerings cross-ref (targetSegmentIds)',
     let errorMessage = ''
     try {
       resolveOrganizationModel({
-        customers: { segments: [] },
+        customers: {},
         offerings: {
-          products: [
-            {
-              id: 'product-path-check',
-              targetSegmentIds: ['ghost-segment']
-            }
-          ]
+          'product-path-check': {
+            id: 'product-path-check',
+            order: 10,
+            targetSegmentIds: ['ghost-segment']
+          }
         }
       })
     } catch (e) {
@@ -294,7 +294,7 @@ describe('resolveOrganizationModel — offerings cross-ref (targetSegmentIds)',
     expect(() =>
       resolveOrganizationModel({
         offerings: {
-          products: [{ id: 'product-no-targets', targetSegmentIds: [] }]
+          'product-no-targets': { id: 'product-no-targets', order: 10, targetSegmentIds: [] }
         }
       })
     ).not.toThrow()
@@ -304,16 +304,12 @@ describe('resolveOrganizationModel — offerings cross-ref (targetSegmentIds)',
     expect(() =>
       resolveOrganizationModel({
         customers: {
-          segments: [
-            { id: 'seg-a', name: 'Segment A' },
-            { id: 'seg-b', name: 'Segment B' }
-          ]
+          'seg-a': { id: 'seg-a', order: 10, name: 'Segment A' },
+          'seg-b': { id: 'seg-b', order: 20, name: 'Segment B' }
         },
         offerings: {
-          products: [
-            { id: 'product-1', targetSegmentIds: ['seg-a'] },
-            { id: 'product-2', targetSegmentIds: ['seg-a', 'seg-b'] }
-          ]
+          'product-1': { id: 'product-1', order: 10, targetSegmentIds: ['seg-a'] },
+          'product-2': { id: 'product-2', order: 20, targetSegmentIds: ['seg-a', 'seg-b'] }
         }
       })
     ).not.toThrow()
@@ -325,48 +321,45 @@ describe('resolveOrganizationModel — offerings cross-ref (targetSegmentIds)',
 // ---------------------------------------------------------------------------
 
 describe('resolveOrganizationModel — offerings cross-ref (deliveryFeatureId)', () => {
-  it('passes when deliveryFeatureId references a declared feature', () => {
-    // 'crm' is in DEFAULT_ORGANIZATION_MODEL.features
+  it('passes when deliveryFeatureId references a declared system', () => {
+    // 'sales.crm' is in DEFAULT_ORGANIZATION_MODEL.systems
     expect(() =>
       resolveOrganizationModel({
         offerings: {
-          products: [
-            {
-              id: 'product-with-delivery',
-              deliveryFeatureId: 'crm'
-            }
-          ]
+          'product-with-delivery': {
+            id: 'product-with-delivery',
+            order: 10,
+            deliveryFeatureId: 'sales.crm'
+          }
         }
       })
     ).not.toThrow()
   })
 
-  it('throws when deliveryFeatureId references a non-existent feature', () => {
+  it('throws when deliveryFeatureId references a non-existent system', () => {
     expect(() =>
       resolveOrganizationModel({
         offerings: {
-          products: [
-            {
-              id: 'product-bad-delivery',
-              deliveryFeatureId: 'nonexistent-feature'
-            }
-          ]
+          'product-bad-delivery': {
+            id: 'product-bad-delivery',
+            order: 10,
+            deliveryFeatureId: 'nonexistent-feature'
+          }
         }
       })
     ).toThrow()
   })
 
-  it('throws with a message referencing the unknown feature id', () => {
+  it('throws with a message referencing the unknown system id', () => {
     let errorMessage = ''
     try {
       resolveOrganizationModel({
         offerings: {
-          products: [
-            {
-              id: 'product-delivery-path',
-              deliveryFeatureId: 'ghost-feature'
-            }
-          ]
+          'product-delivery-path': {
+            id: 'product-delivery-path',
+            order: 10,
+            deliveryFeatureId: 'ghost-feature'
+          }
         }
       })
     } catch (e) {
@@ -379,7 +372,7 @@ describe('resolveOrganizationModel — offerings cross-ref (deliveryFeatureId)',
     expect(() =>
       resolveOrganizationModel({
         offerings: {
-          products: [{ id: 'product-no-delivery' }]
+          'product-no-delivery': { id: 'product-no-delivery', order: 10 }
         }
       })
     ).not.toThrow()
@@ -392,28 +385,30 @@ describe('resolveOrganizationModel — offerings cross-ref (deliveryFeatureId)',
 
 describe('resolveOrganizationModel — offerings domain integration', () => {
   it('merges partial offerings override and preserves empty products default', () => {
-    const model = resolveOrganizationModel({ offerings: { products: [] } })
-    expect(model.offerings.products).toEqual([])
+    const model = resolveOrganizationModel({ offerings: {} })
+    expect(Object.keys(model.offerings)).toHaveLength(0)
   })
 
   it('omitting offerings key entirely resolves to default empty products', () => {
     const model = resolveOrganizationModel({})
     expect(model.offerings).toBeDefined()
-    expect(model.offerings.products).toEqual([])
+    expect(Object.keys(model.offerings)).toHaveLength(0)
   })
 
   it('does not bleed offerings changes into other top-level domains', () => {
     const model = resolveOrganizationModel({
       customers: {
-        segments: [{ id: 'seg-isolation' }]
+        'seg-isolation': { id: 'seg-isolation', order: 10 }
       },
       offerings: {
-        products: [{ id: 'product-isolation', targetSegmentIds: ['seg-isolation'] }]
+        'product-isolation': { id: 'product-isolation', order: 10, targetSegmentIds: ['seg-isolation'] }
       }
     })
     expect(model.identity).toBeDefined()
     expect(model.customers).toBeDefined()
-    expect(model.features).toBeDefined()
+    expect(model.systems).toBeDefined()
+    // Phase 4 (D8): model.navigation removed from top-level OM.
     expect(model.navigation).toBeDefined()
+    expect(model.knowledge).toBeDefined()
   })
 })