@elevasis/core 0.22.0 → 0.24.0

package/src/organization-model/__tests__/migration-helpers.test.ts

@@ -0,0 +1,591 @@
+import { describe, expect, it } from 'vitest'
+import {
+  getAllPipelines,
+  getAllBuildTemplates,
+  getAllProjectStatuses,
+  getAllProspectingStages,
+  getStagesInPipeline
+} from '../migration-helpers'
+import { resolveOrganizationModel } from '../resolve'
+import type { DeepPartial, OrganizationModel } from '../types'
+
+// ---------------------------------------------------------------------------
+// Fixtures — all authored via system.content per Phase 4 schema (D1, D3, D8).
+// No compound-domain paths (model.sales.*, model.prospecting.*, model.projects.*).
+// ---------------------------------------------------------------------------
+
+/**
+ * Minimal model with a pipeline + stages in sales.crm content.
+ * Matches what the Wave 2 canonical OM authors for the Elevasis workspace.
+ */
+function modelWithPipeline(): OrganizationModel {
+  return resolveOrganizationModel({
+    systems: {
+      'sales.crm': {
+        id: 'sales.crm',
+        order: 70,
+        label: 'CRM',
+        enabled: true,
+        lifecycle: 'active',
+        path: '/crm',
+        content: {
+          'default-pipeline': {
+            kind: 'schema',
+            type: 'pipeline',
+            label: 'Default Deal Pipeline',
+            data: { entityId: 'crm.deal' }
+          },
+          'stage-open': {
+            kind: 'schema',
+            type: 'stage',
+            label: 'Open',
+            parentContentId: 'default-pipeline',
+            data: { order: 10, semanticClass: 'open', surfaceIds: [], resourceIds: [] }
+          },
+          'stage-active': {
+            kind: 'schema',
+            type: 'stage',
+            label: 'Active',
+            parentContentId: 'default-pipeline',
+            data: { order: 20, semanticClass: 'active', surfaceIds: [], resourceIds: [] }
+          },
+          'stage-closed-won': {
+            kind: 'schema',
+            type: 'stage',
+            label: 'Closed Won',
+            parentContentId: 'default-pipeline',
+            data: { order: 30, semanticClass: 'closed_won', surfaceIds: [], resourceIds: [] }
+          }
+        }
+      }
+    }
+  } as DeepPartial<OrganizationModel>)
+}
+
+/**
+ * Minimal model with two pipelines on different systems.
+ */
+function modelWithTwoPipelines(): OrganizationModel {
+  return resolveOrganizationModel({
+    systems: {
+      'sales.crm': {
+        id: 'sales.crm',
+        order: 70,
+        label: 'CRM',
+        enabled: true,
+        lifecycle: 'active',
+        path: '/crm',
+        content: {
+          'crm-pipeline': {
+            kind: 'schema',
+            type: 'pipeline',
+            label: 'CRM Pipeline',
+            data: { entityId: 'crm.deal' }
+          },
+          'crm-stage-1': {
+            kind: 'schema',
+            type: 'stage',
+            label: 'Lead',
+            parentContentId: 'crm-pipeline',
+            data: { order: 10, semanticClass: 'open', surfaceIds: [], resourceIds: [] }
+          }
+        }
+      },
+      projects: {
+        id: 'projects',
+        order: 90,
+        label: 'Projects',
+        enabled: true,
+        lifecycle: 'active',
+        path: '/projects',
+        content: {
+          'projects-pipeline': {
+            kind: 'schema',
+            type: 'pipeline',
+            label: 'Projects Pipeline',
+            data: { entityId: 'delivery.project' }
+          },
+          'projects-stage-1': {
+            kind: 'schema',
+            type: 'stage',
+            label: 'Active',
+            parentContentId: 'projects-pipeline',
+            data: { order: 10, semanticClass: 'active', surfaceIds: [], resourceIds: [] }
+          }
+        }
+      }
+    }
+  } as DeepPartial<OrganizationModel>)
+}
+
+/**
+ * Minimal model with a build template + steps in sales.lead-gen content.
+ */
+function modelWithBuildTemplate(): OrganizationModel {
+  return resolveOrganizationModel({
+    systems: {
+      'sales.lead-gen': {
+        id: 'sales.lead-gen',
+        order: 80,
+        label: 'Lead Gen',
+        enabled: true,
+        lifecycle: 'active',
+        path: '/lead-gen',
+        content: {
+          'local-services-template': {
+            kind: 'schema',
+            type: 'template',
+            label: 'Local Services',
+            data: { color: 'blue' }
+          },
+          'step-source': {
+            kind: 'schema',
+            type: 'template-step',
+            label: 'Source Companies',
+            parentContentId: 'local-services-template',
+            data: {
+              stageKey: 'populated',
+              actionKey: 'lead-gen.company.source',
+              primaryEntity: 'company',
+              outputs: ['company'],
+              dependencyMode: 'per-record-eligibility',
+              defaultBatchSize: 100,
+              maxBatchSize: 500
+            }
+          },
+          'step-qualify': {
+            kind: 'schema',
+            type: 'template-step',
+            label: 'Qualify Companies',
+            parentContentId: 'local-services-template',
+            data: {
+              stageKey: 'qualified',
+              actionKey: 'lead-gen.company.qualify',
+              primaryEntity: 'company',
+              outputs: ['company'],
+              dependencyMode: 'per-record-eligibility',
+              defaultBatchSize: 100,
+              maxBatchSize: 500
+            }
+          }
+        }
+      }
+    }
+  } as DeepPartial<OrganizationModel>)
+}
+
+/**
+ * Minimal model with prospecting stages (company + contact) in lead-gen content.
+ * Prospecting stages are distinguished by data.entityKind.
+ */
+function modelWithProspectingStages(): OrganizationModel {
+  return resolveOrganizationModel({
+    systems: {
+      'sales.lead-gen': {
+        id: 'sales.lead-gen',
+        order: 80,
+        label: 'Lead Gen',
+        enabled: true,
+        lifecycle: 'active',
+        path: '/lead-gen',
+        content: {
+          'company-stage-populated': {
+            kind: 'schema',
+            type: 'stage',
+            label: 'Populated',
+            data: { order: 10, entityKind: 'company' }
+          },
+          'company-stage-qualified': {
+            kind: 'schema',
+            type: 'stage',
+            label: 'Qualified',
+            data: { order: 20, entityKind: 'company' }
+          },
+          'contact-stage-discovered': {
+            kind: 'schema',
+            type: 'stage',
+            label: 'Discovered',
+            data: { order: 10, entityKind: 'contact' }
+          }
+        }
+      }
+    }
+  } as DeepPartial<OrganizationModel>)
+}
+
+/**
+ * Minimal model with project statuses (status-flow + status nodes) in projects content.
+ */
+function modelWithProjectStatuses(): OrganizationModel {
+  return resolveOrganizationModel({
+    systems: {
+      projects: {
+        id: 'projects',
+        order: 90,
+        label: 'Projects',
+        enabled: true,
+        lifecycle: 'active',
+        path: '/projects',
+        content: {
+          'project-status-flow': {
+            kind: 'schema',
+            type: 'status-flow',
+            label: 'Project Statuses',
+            data: { appliesTo: 'project' }
+          },
+          'project-status-active': {
+            kind: 'schema',
+            type: 'status',
+            label: 'Active',
+            parentContentId: 'project-status-flow',
+            data: { order: 10 }
+          },
+          'project-status-completed': {
+            kind: 'schema',
+            type: 'status',
+            label: 'Completed',
+            parentContentId: 'project-status-flow',
+            data: { order: 20 }
+          },
+          'milestone-status-flow': {
+            kind: 'schema',
+            type: 'status-flow',
+            label: 'Milestone Statuses',
+            data: { appliesTo: 'milestone' }
+          },
+          'milestone-status-upcoming': {
+            kind: 'schema',
+            type: 'status',
+            label: 'Upcoming',
+            parentContentId: 'milestone-status-flow',
+            data: { order: 10 }
+          },
+          'task-status-flow': {
+            kind: 'schema',
+            type: 'status-flow',
+            label: 'Task Statuses',
+            data: { appliesTo: 'task' }
+          },
+          'task-status-planned': {
+            kind: 'schema',
+            type: 'status',
+            label: 'Planned',
+            parentContentId: 'task-status-flow',
+            data: { order: 10 }
+          },
+          'task-status-in-progress': {
+            kind: 'schema',
+            type: 'status',
+            label: 'In Progress',
+            parentContentId: 'task-status-flow',
+            data: { order: 20 }
+          }
+        }
+      }
+    }
+  } as DeepPartial<OrganizationModel>)
+}
+
+// ---------------------------------------------------------------------------
+// getAllPipelines
+// ---------------------------------------------------------------------------
+describe('getAllPipelines', () => {
+  it('returns all pipelines from a model with system.content pipeline nodes', () => {
+    const model = modelWithPipeline()
+    const result = getAllPipelines(model)
+
+    expect(result.length).toBeGreaterThanOrEqual(1)
+    for (const entry of result) {
+      expect(entry).toHaveProperty('systemPath')
+      expect(entry).toHaveProperty('pipeline')
+      expect(entry.pipeline).toHaveProperty('id')
+      expect(entry.pipeline).toHaveProperty('stages')
+    }
+  })
+
+  it('tags each pipeline with the owning system path', () => {
+    const model = modelWithPipeline()
+    const result = getAllPipelines(model)
+
+    const pipelineEntry = result.find((e) => e.pipeline.id === 'default-pipeline')
+    expect(pipelineEntry).toBeDefined()
+    expect(pipelineEntry?.systemPath).toBe('sales.crm')
+  })
+
+  it('reconstructs pipeline.stages from sibling stage content nodes', () => {
+    const model = modelWithPipeline()
+    const result = getAllPipelines(model)
+
+    const entry = result.find((e) => e.pipeline.id === 'default-pipeline')
+    expect(entry).toBeDefined()
+    expect(entry?.pipeline.stages.length).toBe(3)
+  })
+
+  it('returns stages sorted ascending by order', () => {
+    const model = modelWithPipeline()
+    const [entry] = getAllPipelines(model)
+    expect(entry).toBeDefined()
+
+    const stages = entry!.pipeline.stages
+    for (let i = 1; i < stages.length; i++) {
+      expect(stages[i]!.order).toBeGreaterThanOrEqual(stages[i - 1]!.order)
+    }
+  })
+
+  it('collects pipelines from multiple systems', () => {
+    const model = modelWithTwoPipelines()
+    const result = getAllPipelines(model)
+
+    const ids = result.map((e) => e.pipeline.id).sort()
+    expect(ids).toContain('crm-pipeline')
+    expect(ids).toContain('projects-pipeline')
+  })
+
+  it('returns empty array when no systems have pipeline content nodes', () => {
+    const model = resolveOrganizationModel()
+    expect(getAllPipelines(model)).toEqual([])
+  })
+
+  it('each stage has required shape fields', () => {
+    const model = modelWithPipeline()
+    const [entry] = getAllPipelines(model)
+
+    for (const stage of entry!.pipeline.stages) {
+      expect(stage).toHaveProperty('id')
+      expect(stage).toHaveProperty('label')
+      expect(stage).toHaveProperty('order')
+      expect(stage).toHaveProperty('semanticClass')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// getStagesInPipeline
+// ---------------------------------------------------------------------------
+describe('getStagesInPipeline', () => {
+  it('returns stages for a named pipeline sorted by order', () => {
+    const model = modelWithPipeline()
+    const stages = getStagesInPipeline(model, 'sales.crm', 'default-pipeline')
+
+    expect(stages.length).toBe(3)
+    for (let i = 1; i < stages.length; i++) {
+      expect(stages[i]!.order).toBeGreaterThanOrEqual(stages[i - 1]!.order)
+    }
+  })
+
+  it('returns empty array for an unknown system path', () => {
+    const model = modelWithPipeline()
+    expect(getStagesInPipeline(model, 'nonexistent.system', 'default-pipeline')).toEqual([])
+  })
+
+  it('returns empty array for an unknown pipeline id', () => {
+    const model = modelWithPipeline()
+    expect(getStagesInPipeline(model, 'sales.crm', 'nonexistent-pipeline')).toEqual([])
+  })
+
+  it('does not include pipeline nodes themselves — only stage nodes', () => {
+    const model = modelWithPipeline()
+    const stages = getStagesInPipeline(model, 'sales.crm', 'default-pipeline')
+
+    // Every result should be a stage, not a pipeline
+    expect(stages.every((s) => 'semanticClass' in s)).toBe(true)
+  })
+
+  it('only returns stages belonging to the specified pipeline via parentContentId', () => {
+    const model = modelWithTwoPipelines()
+
+    const crmStages = getStagesInPipeline(model, 'sales.crm', 'crm-pipeline')
+    expect(crmStages.map((s) => s.id)).toContain('crm-stage-1')
+
+    const projectsStages = getStagesInPipeline(model, 'projects', 'projects-pipeline')
+    expect(projectsStages.map((s) => s.id)).toContain('projects-stage-1')
+
+    // CRM stages should not appear in project pipeline results
+    expect(projectsStages.map((s) => s.id)).not.toContain('crm-stage-1')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// getAllBuildTemplates
+// ---------------------------------------------------------------------------
+describe('getAllBuildTemplates', () => {
+  it('returns all build templates from content nodes', () => {
+    const model = modelWithBuildTemplate()
+    const result = getAllBuildTemplates(model)
+
+    expect(result.length).toBeGreaterThanOrEqual(1)
+    for (const template of result) {
+      expect(template).toHaveProperty('id')
+      expect(template).toHaveProperty('steps')
+      expect(template.steps.length).toBeGreaterThanOrEqual(1)
+    }
+  })
+
+  it('reconstructs template steps from sibling template-step content nodes', () => {
+    const model = modelWithBuildTemplate()
+    const result = getAllBuildTemplates(model)
+
+    const template = result.find((t) => t.id === 'local-services-template')
+    expect(template).toBeDefined()
+    expect(template?.steps.length).toBe(2)
+  })
+
+  it('returns empty array when no systems have template content nodes', () => {
+    const model = resolveOrganizationModel()
+    expect(getAllBuildTemplates(model)).toEqual([])
+  })
+
+  it('each template has a non-empty label', () => {
+    const model = modelWithBuildTemplate()
+    const result = getAllBuildTemplates(model)
+
+    for (const template of result) {
+      expect(template.label.length).toBeGreaterThan(0)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// getAllProspectingStages
+// ---------------------------------------------------------------------------
+describe('getAllProspectingStages', () => {
+  it('returns company stages from content nodes with data.entityKind === "company"', () => {
+    const model = modelWithProspectingStages()
+    const stages = getAllProspectingStages(model, 'company')
+
+    expect(stages.length).toBe(2)
+    expect(stages.map((s) => s.id).sort()).toEqual(['company-stage-populated', 'company-stage-qualified'].sort())
+  })
+
+  it('returns contact stages from content nodes with data.entityKind === "contact"', () => {
+    const model = modelWithProspectingStages()
+    const stages = getAllProspectingStages(model, 'contact')
+
+    expect(stages.length).toBe(1)
+    expect(stages[0]?.id).toBe('contact-stage-discovered')
+  })
+
+  it('returns company and contact stage sets from distinct data.entityKind values', () => {
+    const model = modelWithProspectingStages()
+    const companyIds = new Set(getAllProspectingStages(model, 'company').map((s) => s.id))
+    const contactIds = new Set(getAllProspectingStages(model, 'contact').map((s) => s.id))
+
+    expect(companyIds.size).toBeGreaterThan(0)
+    expect(contactIds.size).toBeGreaterThan(0)
+
+    // No overlap — distinct entity kinds
+    for (const id of contactIds) {
+      expect(companyIds.has(id)).toBe(false)
+    }
+  })
+
+  it('returns stages sorted ascending by order', () => {
+    const model = modelWithProspectingStages()
+    const stages = getAllProspectingStages(model, 'company')
+
+    for (let i = 1; i < stages.length; i++) {
+      expect(stages[i]!.order).toBeGreaterThanOrEqual(stages[i - 1]!.order)
+    }
+  })
+
+  it('returns empty array when no systems have prospecting stage content nodes', () => {
+    const model = resolveOrganizationModel()
+    expect(getAllProspectingStages(model, 'company')).toEqual([])
+    expect(getAllProspectingStages(model, 'contact')).toEqual([])
+  })
+
+  it('each stage has required shape fields', () => {
+    const model = modelWithProspectingStages()
+    const stages = getAllProspectingStages(model, 'company')
+
+    for (const stage of stages) {
+      expect(stage).toHaveProperty('id')
+      expect(stage).toHaveProperty('label')
+      expect(stage).toHaveProperty('order')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// getAllProjectStatuses
+// ---------------------------------------------------------------------------
+describe('getAllProjectStatuses', () => {
+  it('returns project statuses from status-flow + status content nodes', () => {
+    const model = modelWithProjectStatuses()
+    const statuses = getAllProjectStatuses(model, 'project')
+
+    expect(statuses.length).toBe(2)
+    expect(statuses.map((s) => s.id).sort()).toEqual(['project-status-active', 'project-status-completed'].sort())
+  })
+
+  it('returns milestone statuses from milestone status-flow', () => {
+    const model = modelWithProjectStatuses()
+    const statuses = getAllProjectStatuses(model, 'milestone')
+
+    expect(statuses.length).toBe(1)
+    expect(statuses[0]?.id).toBe('milestone-status-upcoming')
+  })
+
+  it('returns task statuses from task status-flow', () => {
+    const model = modelWithProjectStatuses()
+    const statuses = getAllProjectStatuses(model, 'task')
+
+    expect(statuses.length).toBe(2)
+    expect(statuses.map((s) => s.id).sort()).toEqual(['task-status-in-progress', 'task-status-planned'].sort())
+  })
+
+  it('returns statuses sorted ascending by order', () => {
+    const model = modelWithProjectStatuses()
+    const statuses = getAllProjectStatuses(model, 'project')
+
+    for (let i = 1; i < statuses.length; i++) {
+      expect(statuses[i]!.order).toBeGreaterThanOrEqual(statuses[i - 1]!.order)
+    }
+  })
+
+  it('three entity-types return distinct status sets', () => {
+    const model = modelWithProjectStatuses()
+    const projectIds = new Set(getAllProjectStatuses(model, 'project').map((s) => s.id))
+    const milestoneIds = new Set(getAllProjectStatuses(model, 'milestone').map((s) => s.id))
+    const taskIds = new Set(getAllProjectStatuses(model, 'task').map((s) => s.id))
+
+    expect(projectIds.size).toBeGreaterThan(0)
+    expect(milestoneIds.size).toBeGreaterThan(0)
+    expect(taskIds.size).toBeGreaterThan(0)
+
+    // Cross-check: no overlap between project/task
+    for (const id of taskIds) {
+      expect(projectIds.has(id)).toBe(false)
+    }
+  })
+
+  it('each status has required shape fields', () => {
+    const model = modelWithProjectStatuses()
+
+    for (const kind of ['project', 'milestone', 'task'] as const) {
+      const statuses = getAllProjectStatuses(model, kind)
+      for (const status of statuses) {
+        expect(status).toHaveProperty('id')
+        expect(status).toHaveProperty('label')
+        expect(status).toHaveProperty('order')
+      }
+    }
+  })
+
+  it('returns empty array when no systems have status-flow content nodes', () => {
+    const model = resolveOrganizationModel()
+    expect(getAllProjectStatuses(model, 'project')).toEqual([])
+    expect(getAllProjectStatuses(model, 'milestone')).toEqual([])
+    expect(getAllProjectStatuses(model, 'task')).toEqual([])
+  })
+
+  it('only collects status nodes belonging to the correct status-flow via parentContentId', () => {
+    const model = modelWithProjectStatuses()
+
+    // Task statuses should not appear in project results
+    const projectStatuses = getAllProjectStatuses(model, 'project')
+    const projectStatusIds = new Set(projectStatuses.map((s) => s.id))
+    expect(projectStatusIds.has('task-status-planned')).toBe(false)
+    expect(projectStatusIds.has('task-status-in-progress')).toBe(false)
+  })
+})