@elevasis/core 0.5.0 → 0.7.0

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

@@ -0,0 +1,419 @@
+import { describe, expect, it } from 'vitest'
+import {
+  OfferingsDomainSchema,
+  ProductSchema,
+  PricingModelSchema,
+  DEFAULT_ORGANIZATION_MODEL_OFFERINGS
+} from '../../domains/offerings'
+import { resolveOrganizationModel } from '../../resolve'
+
+// ---------------------------------------------------------------------------
+// Group 1: ProductSchema — positive parse
+// ---------------------------------------------------------------------------
+
+describe('ProductSchema — positive parse', () => {
+  it('accepts a fully-populated product', () => {
+    const result = ProductSchema.safeParse({
+      id: 'product-starter-plan',
+      name: 'Starter Plan',
+      description: 'Full-service automation for small teams.',
+      pricingModel: 'subscription',
+      price: 299,
+      currency: 'USD',
+      targetSegmentIds: ['seg-smb'],
+      deliveryFeatureId: 'crm'
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts a minimal product — only id required', () => {
+    const result = ProductSchema.safeParse({ id: 'product-minimal' })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.id).toBe('product-minimal')
+      expect(result.data.name).toBe('')
+      expect(result.data.description).toBe('')
+      expect(result.data.pricingModel).toBe('custom')
+      expect(result.data.price).toBe(0)
+      expect(result.data.currency).toBe('USD')
+      expect(result.data.targetSegmentIds).toEqual([])
+      expect(result.data.deliveryFeatureId).toBeUndefined()
+    }
+  })
+
+  it('trims whitespace from id and name', () => {
+    const result = ProductSchema.safeParse({
+      id: '  product-trim  ',
+      name: '  Trimmed Name  '
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.id).toBe('product-trim')
+      expect(result.data.name).toBe('Trimmed Name')
+    }
+  })
+
+  it('accepts price of 0 (free tier)', () => {
+    const result = ProductSchema.safeParse({
+      id: 'product-free',
+      pricingModel: 'subscription',
+      price: 0
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.price).toBe(0)
+    }
+  })
+
+  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 })
+      expect(result.success).toBe(true)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 2: ProductSchema — default values
+// ---------------------------------------------------------------------------
+
+describe('ProductSchema — default values', () => {
+  it('pricingModel defaults to "custom"', () => {
+    const result = ProductSchema.safeParse({ id: 'product-defaults' })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.pricingModel).toBe('custom')
+    }
+  })
+
+  it('price defaults to 0', () => {
+    const result = ProductSchema.safeParse({ id: 'product-defaults' })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.price).toBe(0)
+    }
+  })
+
+  it('currency defaults to "USD"', () => {
+    const result = ProductSchema.safeParse({ id: 'product-defaults' })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.currency).toBe('USD')
+    }
+  })
+
+  it('targetSegmentIds defaults to empty array', () => {
+    const result = ProductSchema.safeParse({ id: 'product-defaults' })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.targetSegmentIds).toEqual([])
+    }
+  })
+
+  it('deliveryFeatureId defaults to undefined (field is optional)', () => {
+    const result = ProductSchema.safeParse({ id: 'product-defaults' })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.deliveryFeatureId).toBeUndefined()
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 3: ProductSchema — negative parse (wrong types / constraints)
+// ---------------------------------------------------------------------------
+
+describe('ProductSchema — negative parse', () => {
+  it('rejects missing id', () => {
+    const result = ProductSchema.safeParse({ name: 'No ID Product' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects empty string id', () => {
+    const result = ProductSchema.safeParse({ id: '' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects whitespace-only id (trims to empty string)', () => {
+    const result = ProductSchema.safeParse({ id: '   ' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects an unknown pricingModel value', () => {
+    const result = ProductSchema.safeParse({ id: 'product-bad-model', pricingModel: 'freemium' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects price below 0', () => {
+    const result = ProductSchema.safeParse({ id: 'product-negative-price', price: -1 })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects price as a string', () => {
+    const result = ProductSchema.safeParse({ id: 'product-string-price', 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' })
+    expect(result.success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 4: PricingModelSchema — enum coverage
+// ---------------------------------------------------------------------------
+
+describe('PricingModelSchema — enum', () => {
+  it('has exactly four values', () => {
+    const result = PricingModelSchema.safeParse('one-time')
+    expect(result.success).toBe(true)
+    // Verify the full enum options list matches expected set
+    expect(PricingModelSchema.options).toEqual(['one-time', 'subscription', 'usage-based', 'custom'])
+  })
+
+  it('rejects an empty string', () => {
+    const result = PricingModelSchema.safeParse('')
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects a numeric value', () => {
+    const result = PricingModelSchema.safeParse(42)
+    expect(result.success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 5: OfferingsDomainSchema — structural
+// ---------------------------------------------------------------------------
+
+describe('OfferingsDomainSchema — structural', () => {
+  it('accepts an empty products array', () => {
+    const result = OfferingsDomainSchema.safeParse({ products: [] })
+    expect(result.success).toBe(true)
+  })
+
+  it('defaults products to empty array when key is omitted', () => {
+    const result = OfferingsDomainSchema.safeParse({})
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.products).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 }
+      ]
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.products).toHaveLength(2)
+    }
+  })
+
+  it('rejects products as a non-array value', () => {
+    const result = OfferingsDomainSchema.safeParse({ products: 'not an array' })
+    expect(result.success).toBe(false)
+  })
+
+  it('DEFAULT_ORGANIZATION_MODEL_OFFERINGS constant matches schema parse of empty object', () => {
+    const result = OfferingsDomainSchema.safeParse({})
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data).toEqual(DEFAULT_ORGANIZATION_MODEL_OFFERINGS)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 6: Cross-ref validation via resolveOrganizationModel
+// ---------------------------------------------------------------------------
+
+describe('resolveOrganizationModel — offerings cross-ref (targetSegmentIds)', () => {
+  it('passes when targetSegmentIds references a declared customer segment', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        customers: {
+          segments: [{ id: 'seg-agencies', name: 'SMB Agencies' }]
+        },
+        offerings: {
+          products: [
+            {
+              id: 'product-starter',
+              name: 'Starter Plan',
+              pricingModel: 'subscription',
+              targetSegmentIds: ['seg-agencies']
+            }
+          ]
+        }
+      })
+    ).not.toThrow()
+  })
+
+  it('throws when targetSegmentIds references a non-existent segment', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        customers: { segments: [] },
+        offerings: {
+          products: [
+            {
+              id: 'product-bad-ref',
+              targetSegmentIds: ['nonexistent-segment']
+            }
+          ]
+        }
+      })
+    ).toThrow()
+  })
+
+  it('throws with a message referencing the unknown segment id', () => {
+    let errorMessage = ''
+    try {
+      resolveOrganizationModel({
+        customers: { segments: [] },
+        offerings: {
+          products: [
+            {
+              id: 'product-path-check',
+              targetSegmentIds: ['ghost-segment']
+            }
+          ]
+        }
+      })
+    } catch (e) {
+      errorMessage = String(e)
+    }
+    expect(errorMessage).toContain('ghost-segment')
+  })
+
+  it('passes when targetSegmentIds is empty (no refs required)', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        offerings: {
+          products: [{ id: 'product-no-targets', targetSegmentIds: [] }]
+        }
+      })
+    ).not.toThrow()
+  })
+
+  it('passes when multiple products each reference a valid segment', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        customers: {
+          segments: [
+            { id: 'seg-a', name: 'Segment A' },
+            { id: 'seg-b', name: 'Segment B' }
+          ]
+        },
+        offerings: {
+          products: [
+            { id: 'product-1', targetSegmentIds: ['seg-a'] },
+            { id: 'product-2', targetSegmentIds: ['seg-a', 'seg-b'] }
+          ]
+        }
+      })
+    ).not.toThrow()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 7: Cross-ref validation — deliveryFeatureId
+// ---------------------------------------------------------------------------
+
+describe('resolveOrganizationModel — offerings cross-ref (deliveryFeatureId)', () => {
+  it('passes when deliveryFeatureId references a declared feature', () => {
+    // 'crm' is in DEFAULT_ORGANIZATION_MODEL.features
+    expect(() =>
+      resolveOrganizationModel({
+        offerings: {
+          products: [
+            {
+              id: 'product-with-delivery',
+              deliveryFeatureId: 'crm'
+            }
+          ]
+        }
+      })
+    ).not.toThrow()
+  })
+
+  it('throws when deliveryFeatureId references a non-existent feature', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        offerings: {
+          products: [
+            {
+              id: 'product-bad-delivery',
+              deliveryFeatureId: 'nonexistent-feature'
+            }
+          ]
+        }
+      })
+    ).toThrow()
+  })
+
+  it('throws with a message referencing the unknown feature id', () => {
+    let errorMessage = ''
+    try {
+      resolveOrganizationModel({
+        offerings: {
+          products: [
+            {
+              id: 'product-delivery-path',
+              deliveryFeatureId: 'ghost-feature'
+            }
+          ]
+        }
+      })
+    } catch (e) {
+      errorMessage = String(e)
+    }
+    expect(errorMessage).toContain('ghost-feature')
+  })
+
+  it('passes when deliveryFeatureId is absent (field is optional)', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        offerings: {
+          products: [{ id: 'product-no-delivery' }]
+        }
+      })
+    ).not.toThrow()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 8: Integration — resolveOrganizationModel general
+// ---------------------------------------------------------------------------
+
+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([])
+  })
+
+  it('omitting offerings key entirely resolves to default empty products', () => {
+    const model = resolveOrganizationModel({})
+    expect(model.offerings).toBeDefined()
+    expect(model.offerings.products).toEqual([])
+  })
+
+  it('does not bleed offerings changes into other top-level domains', () => {
+    const model = resolveOrganizationModel({
+      customers: {
+        segments: [{ id: 'seg-isolation' }]
+      },
+      offerings: {
+        products: [{ id: 'product-isolation', targetSegmentIds: ['seg-isolation'] }]
+      }
+    })
+    expect(model.identity).toBeDefined()
+    expect(model.customers).toBeDefined()
+    expect(model.features).toBeDefined()
+    expect(model.navigation).toBeDefined()
+  })
+})

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

@@ -0,0 +1,203 @@
+import { describe, expect, it } from 'vitest'
+import {
+  DEFAULT_ORGANIZATION_MODEL_OPERATIONS,
+  OperationEntrySchema,
+  OperationsDomainSchema,
+  OperationSemanticClassSchema
+} from '../../domains/operations'
+
+// ---------------------------------------------------------------------------
+// Group 1: OperationEntrySchema — positive parse
+// ---------------------------------------------------------------------------
+
+describe('OperationEntrySchema — positive parse', () => {
+  it('accepts a fully-specified entry (id, label, semanticClass, featureId, supportedStatusSemanticClass)', () => {
+    const result = OperationEntrySchema.safeParse({
+      id: 'operations.queue',
+      label: 'HITL Queue',
+      semanticClass: 'queue',
+      featureId: 'operations',
+      supportedStatusSemanticClass: ['queue']
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts a minimal entry without optional fields', () => {
+    const result = OperationEntrySchema.safeParse({
+      id: 'operations.sessions',
+      label: 'Sessions',
+      semanticClass: 'sessions'
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.featureId).toBeUndefined()
+      expect(result.data.supportedStatusSemanticClass).toBeUndefined()
+    }
+  })
+
+  it('trims whitespace from id and label', () => {
+    const result = OperationEntrySchema.safeParse({
+      id: '  trimmed-id  ',
+      label: '  Trimmed Label  ',
+      semanticClass: 'executions'
+    })
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.id).toBe('trimmed-id')
+      expect(result.data.label).toBe('Trimmed Label')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 2: OperationEntrySchema — negative parse
+// ---------------------------------------------------------------------------
+
+describe('OperationEntrySchema — negative parse', () => {
+  it('rejects a missing id field', () => {
+    const result = OperationEntrySchema.safeParse({
+      label: 'No ID',
+      semanticClass: 'queue'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects a missing label field', () => {
+    const result = OperationEntrySchema.safeParse({
+      id: 'operations.queue',
+      semanticClass: 'queue'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects a missing semanticClass field', () => {
+    const result = OperationEntrySchema.safeParse({
+      id: 'operations.queue',
+      label: 'HITL Queue'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects an unknown semanticClass value', () => {
+    const result = OperationEntrySchema.safeParse({
+      id: 'some.entry',
+      label: 'Some Entry',
+      semanticClass: 'not-a-real-class'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects a non-string id (number)', () => {
+    const result = OperationEntrySchema.safeParse({
+      id: 42,
+      label: 'Label',
+      semanticClass: 'queue'
+    })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects an empty string label (min length 1 after trim)', () => {
+    const result = OperationEntrySchema.safeParse({
+      id: 'some.entry',
+      label: '   ',
+      semanticClass: 'queue'
+    })
+    expect(result.success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 3: OperationsDomainSchema — structural tests
+// ---------------------------------------------------------------------------
+
+describe('OperationsDomainSchema — structural tests', () => {
+  it('accepts an entries-empty domain object', () => {
+    const result = OperationsDomainSchema.safeParse({ entries: [] })
+    expect(result.success).toBe(true)
+  })
+
+  it('applies an empty-array default when entries is omitted', () => {
+    const result = OperationsDomainSchema.safeParse({})
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.entries).toEqual([])
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 4: Semantic class enum — all 5 values declared
+// ---------------------------------------------------------------------------
+
+describe('OperationSemanticClassSchema — enum coverage', () => {
+  const expectedClasses = ['queue', 'executions', 'sessions', 'notifications', 'schedules'] as const
+
+  it('enum exposes exactly 5 semantic classes', () => {
+    expect(OperationSemanticClassSchema.options).toHaveLength(5)
+  })
+
+  it.each(expectedClasses)('"%s" is a valid semanticClass value', (cls) => {
+    const result = OperationSemanticClassSchema.safeParse(cls)
+    expect(result.success).toBe(true)
+  })
+
+  it('every entry in the seed uses one of the 5 known semanticClass values', () => {
+    const valid = new Set<string>(OperationSemanticClassSchema.options)
+    for (const entry of DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries) {
+      expect(
+        valid.has(entry.semanticClass),
+        `Unexpected semanticClass "${entry.semanticClass}" on entry "${entry.id}"`
+      ).toBe(true)
+    }
+  })
+
+  it('all 5 semanticClass values have exactly one seed entry', () => {
+    const presentClasses = new Set(DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.map((e) => e.semanticClass))
+    for (const cls of OperationSemanticClassSchema.options) {
+      expect(presentClasses.has(cls), `No seed entry found for semanticClass "${cls}"`).toBe(true)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Group 5: Seed completeness
+// ---------------------------------------------------------------------------
+
+describe('DEFAULT_ORGANIZATION_MODEL_OPERATIONS seed — completeness', () => {
+  it('has exactly 5 entries (one per entity category)', () => {
+    expect(DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries).toHaveLength(5)
+  })
+
+  it('all entry ids are unique', () => {
+    const ids = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.map((e) => e.id)
+    const uniqueIds = new Set(ids)
+    expect(uniqueIds.size).toBe(ids.length)
+  })
+
+  it('every entry has a non-empty id, label, and semanticClass', () => {
+    for (const entry of DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries) {
+      expect(entry.id.length).toBeGreaterThan(0)
+      expect(entry.label.length).toBeGreaterThan(0)
+      expect(entry.semanticClass.length).toBeGreaterThan(0)
+    }
+  })
+
+  it('queue entry references queue status semantic class', () => {
+    const queueEntry = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.find((e) => e.semanticClass === 'queue')
+    expect(queueEntry).toBeDefined()
+    expect(queueEntry?.supportedStatusSemanticClass).toContain('queue')
+  })
+
+  it('executions entry references execution status semantic class', () => {
+    const execEntry = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.find((e) => e.semanticClass === 'executions')
+    expect(execEntry).toBeDefined()
+    expect(execEntry?.supportedStatusSemanticClass).toContain('execution')
+  })
+
+  it('schedules entry references schedule and schedule.run status semantic classes', () => {
+    const schedEntry = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.find((e) => e.semanticClass === 'schedules')
+    expect(schedEntry).toBeDefined()
+    expect(schedEntry?.supportedStatusSemanticClass).toContain('schedule')
+    expect(schedEntry?.supportedStatusSemanticClass).toContain('schedule.run')
+  })
+})