@elevasis/core 0.22.0 → 0.24.0

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

@@ -0,0 +1,549 @@
+/**
+ * recursive-system-schema.test.ts
+ *
+ * Tests for B3, B4, B5, L19, and D2 content-node refines in OrganizationModelSchema.
+ * Each constraint has ≥1 positive (passes) and ≥1 negative (error) assertion.
+ *
+ * B3 — Cycle detection: parentContentId chain must not form a cycle.
+ * B4 — Same-system-only: parentContentId must resolve within the same content map.
+ * B5 — Payload validation: registered (kind, type) pairs validate data.
+ * L19 — Same-meta-kind parent constraint.
+ * D2 — Unregistered (kind, type) passes through without error.
+ */
+import { describe, expect, it } from 'vitest'
+import { resolveOrganizationModel } from '../resolve'
+import { getSystem, listAllSystems } from '../helpers'
+import { OrganizationModelSchema } from '../schema'
+import { DEFAULT_ORGANIZATION_MODEL_BRANDING } from '../domains/branding'
+
+// Phase 4 (D8): sales, prospecting, projects top-level OM fields removed.
+// DEFAULT_ORGANIZATION_MODEL_SALES / _PROSPECTING / _PROJECTS no longer exported.
+// makeMinimalModel no longer includes those fields — they were extra props that
+// the schema stripped anyway. Removing them has no effect on the test fixtures.
+
+// ---------------------------------------------------------------------------
+// Minimal model factory (shared with schema.test.ts convention)
+// ---------------------------------------------------------------------------
+
+function makeSystem(id: string, path = `/${id.replaceAll('.', '/')}`) {
+  return {
+    id,
+    order: 10,
+    label: id,
+    enabled: true,
+    lifecycle: 'active' as const,
+    path
+  }
+}
+
+function makeMinimalModel(systems: Record<string, unknown> = {}, extra: Record<string, unknown> = {}) {
+  const entityOwnerId = Object.keys(systems)[0] ?? 'dashboard'
+  return {
+    version: 1 as const,
+    branding: DEFAULT_ORGANIZATION_MODEL_BRANDING,
+    entities: {
+      'crm.deal': { id: 'crm.deal', order: 10, label: 'Deal', ownedBySystemId: entityOwnerId },
+      'leadgen.list': { id: 'leadgen.list', order: 20, label: 'Lead List', ownedBySystemId: entityOwnerId },
+      'leadgen.company': { id: 'leadgen.company', order: 30, label: 'Lead Company', ownedBySystemId: entityOwnerId },
+      'leadgen.contact': { id: 'leadgen.contact', order: 40, label: 'Lead Contact', ownedBySystemId: entityOwnerId },
+      'delivery.project': { id: 'delivery.project', order: 50, label: 'Project', ownedBySystemId: entityOwnerId },
+      'delivery.milestone': {
+        id: 'delivery.milestone',
+        order: 60,
+        label: 'Milestone',
+        ownedBySystemId: entityOwnerId
+      },
+      'delivery.task': { id: 'delivery.task', order: 70, label: 'Task', ownedBySystemId: entityOwnerId }
+    },
+    systems,
+    ...extra
+  }
+}
+
+function getIssueMessages(data: unknown): string[] {
+  const result = OrganizationModelSchema.safeParse(data)
+  if (result.success) return []
+  return result.error.issues.map((issue) => issue.message)
+}
+
+function parseSucceeds(data: unknown): boolean {
+  return OrganizationModelSchema.safeParse(data).success
+}
+
+// ---------------------------------------------------------------------------
+// 2-level subsystem + content fixture round-trips
+// ---------------------------------------------------------------------------
+
+describe('2-level subsystems + content (positive, structural)', () => {
+  it('parses a model with a top-level system that has a subsystem via resolveOrganizationModel', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        ops: { id: 'ops', order: 99, label: 'Ops', enabled: true, path: '/ops' },
+        'ops.sub': {
+          id: 'ops.sub',
+          order: 100,
+          label: 'Sub',
+          enabled: true,
+          path: '/ops/sub',
+          parentSystemId: 'ops'
+        }
+      }
+    })
+    expect(model.systems['ops']).toBeDefined()
+    expect(model.systems['ops.sub']).toBeDefined()
+  })
+
+  it('parses a system with a content map carrying a valid registered node', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          'main-pipeline': {
+            kind: 'schema',
+            type: 'pipeline',
+            label: 'Main Pipeline',
+            data: { entityId: 'crm.deal' }
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+
+  it('parses a 2-level subsystem hierarchy with content at each level', () => {
+    const data = makeMinimalModel({
+      parent: {
+        ...makeSystem('parent', '/parent'),
+        content: {
+          'parent-config': {
+            kind: 'config',
+            type: 'kv',
+            label: 'Parent Config',
+            data: { entries: { maxBatch: 10 } }
+          }
+        }
+      },
+      'parent.child': {
+        ...makeSystem('parent.child', '/parent/child'),
+        parentSystemId: 'parent',
+        content: {
+          'child-config': {
+            kind: 'config',
+            type: 'kv',
+            label: 'Child Config',
+            data: { entries: { timeout: 5000 } }
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+
+  it('parses canonical systems children and keeps subsystems as a compatibility alias', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        parent: {
+          ...makeSystem('parent', '/parent'),
+          systems: {
+            child: {
+              ...makeSystem('child', '/parent/child'),
+              content: {
+                pipeline: {
+                  kind: 'schema',
+                  type: 'pipeline',
+                  label: 'Pipeline',
+                  data: { entityId: 'crm.deal' }
+                }
+              }
+            }
+          }
+        }
+      }
+    })
+
+    expect(model.systems.parent?.systems?.child).toBeDefined()
+    expect(model.systems.parent?.subsystems?.child).toBeDefined()
+    expect(getSystem(model, 'parent.child')?.label).toBe('child')
+    expect(listAllSystems(model).map((entry) => entry.path)).toContain('parent.child')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// B3 — parentContentId cycle detection
+// ---------------------------------------------------------------------------
+
+describe('B3 — parentContentId cycle detection', () => {
+  it('POSITIVE: linear parentContentId chain (A → B, B has no parent) parses', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          flow: {
+            kind: 'schema',
+            type: 'status-flow',
+            label: 'Flow',
+            data: { appliesTo: 'project' }
+          },
+          status: {
+            kind: 'schema',
+            type: 'status',
+            label: 'Active',
+            parentContentId: 'flow',
+            data: { semanticClass: 'active' }
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+
+  it('NEGATIVE: direct self-cycle (node points to itself) produces cycle error', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          'self-ref': {
+            kind: 'schema',
+            type: 'pipeline',
+            label: 'Self Ref',
+            parentContentId: 'self-ref'
+          }
+        }
+      }
+    })
+    const messages = getIssueMessages(data)
+    expect(messages.some((m) => m.includes('parentContentId cycle'))).toBe(true)
+  })
+
+  it('NEGATIVE: indirect 2-node cycle (A → B → A) produces cycle error', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          alpha: {
+            kind: 'schema',
+            type: 'pipeline',
+            label: 'Alpha',
+            parentContentId: 'beta'
+          },
+          beta: {
+            kind: 'schema',
+            type: 'stage',
+            label: 'Beta',
+            parentContentId: 'alpha'
+          }
+        }
+      }
+    })
+    const messages = getIssueMessages(data)
+    expect(messages.some((m) => m.includes('parentContentId cycle'))).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// B4 — parentContentId must resolve within the same system content map
+// ---------------------------------------------------------------------------
+
+describe('B4 — parentContentId cross-system reference error', () => {
+  it('POSITIVE: parentContentId referencing a sibling in the same content map parses', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          parent: {
+            kind: 'schema',
+            type: 'status-flow',
+            label: 'Status Flow',
+            data: { appliesTo: 'task' }
+          },
+          child: {
+            kind: 'schema',
+            type: 'status',
+            label: 'Open',
+            parentContentId: 'parent',
+            data: { semanticClass: 'active' }
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+
+  it('NEGATIVE: parentContentId referencing a non-existent localId produces B4 error', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          orphan: {
+            kind: 'schema',
+            type: 'stage',
+            label: 'Orphan',
+            parentContentId: 'does-not-exist-in-this-system'
+          }
+        }
+      }
+    })
+    const messages = getIssueMessages(data)
+    expect(
+      messages.some((m) => m.includes('does not resolve within the same system') || m.includes('parentContentId'))
+    ).toBe(true)
+  })
+
+  it('NEGATIVE: cross-system localId reference (sibling system content is a different map)', () => {
+    // "other-system" has "shared-node" but "hub" does NOT — so parentContentId is cross-system
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          child: {
+            kind: 'schema',
+            type: 'stage',
+            label: 'Child',
+            parentContentId: 'shared-node' // exists in other-system, not hub
+          }
+        }
+      },
+      other: {
+        ...makeSystem('other', '/other'),
+        content: {
+          'shared-node': {
+            kind: 'schema',
+            type: 'pipeline',
+            label: 'Shared Node'
+          }
+        }
+      }
+    })
+    const messages = getIssueMessages(data)
+    expect(messages.some((m) => m.includes('parentContentId'))).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// B5 — Payload validation for registered (kind, type) pairs
+// ---------------------------------------------------------------------------
+
+describe('B5 — payload validation for registered kinds', () => {
+  it('POSITIVE: valid schema:pipeline data passes payload validation', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          pipe: {
+            kind: 'schema',
+            type: 'pipeline',
+            label: 'Pipeline',
+            data: { entityId: 'crm.deal' }
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+
+  it('NEGATIVE: invalid schema:pipeline data (missing required entityId) produces payload error', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          pipe: {
+            kind: 'schema',
+            type: 'pipeline',
+            label: 'Pipeline',
+            data: { kanbanColor: 'blue' } // entityId is required
+          }
+        }
+      }
+    })
+    const messages = getIssueMessages(data)
+    expect(messages.some((m) => m.includes('data failed payload validation') || m.includes('payload'))).toBe(true)
+  })
+
+  it('POSITIVE: valid config:kv data passes payload validation', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          cfg: {
+            kind: 'config',
+            type: 'kv',
+            label: 'Config',
+            data: { entries: { flag: true, limit: 100 } }
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+
+  it('NEGATIVE: invalid config:kv data (entries contains an object value) produces payload error', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          cfg: {
+            kind: 'config',
+            type: 'kv',
+            label: 'Config',
+            data: { entries: { nested: { key: 'value' } } } // object not allowed, only primitives
+          }
+        }
+      }
+    })
+    const messages = getIssueMessages(data)
+    expect(messages.some((m) => m.includes('payload') || m.includes('data'))).toBe(true)
+  })
+
+  it('POSITIVE: valid schema:status-flow data passes', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          flow: {
+            kind: 'schema',
+            type: 'status-flow',
+            label: 'Flow',
+            data: { appliesTo: 'project' }
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+
+  it('NEGATIVE: invalid schema:status-flow data (bad appliesTo value)', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          flow: {
+            kind: 'schema',
+            type: 'status-flow',
+            label: 'Flow',
+            data: { appliesTo: 'organization' } // not in enum
+          }
+        }
+      }
+    })
+    const messages = getIssueMessages(data)
+    expect(messages.some((m) => m.includes('payload') || m.includes('data'))).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// D2 — Unregistered (kind, type) passes through without error
+// ---------------------------------------------------------------------------
+
+describe('D2 — unregistered (kind, type) passes through (no error)', () => {
+  it('unregistered tenant kind passes schema validation without error', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          custom: {
+            kind: 'tenant',
+            type: 'custom-thing',
+            label: 'Custom Thing',
+            data: { anything: 'goes', nested: { ok: true } }
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+
+  it('unregistered kind with invalid-looking data still passes through (no payload schema to validate against)', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          unknown: {
+            kind: 'experimental',
+            type: 'prototype',
+            label: 'Prototype',
+            data: { malformed: [1, 2, 3], extra: null }
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+
+  it('unregistered kind with parentContentId that resolves in same system also passes', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          parent: {
+            kind: 'tenant',
+            type: 'group',
+            label: 'Parent Group'
+          },
+          child: {
+            kind: 'tenant',
+            type: 'item',
+            label: 'Child Item',
+            parentContentId: 'parent'
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// L19 — Same-meta-kind parent constraint
+// ---------------------------------------------------------------------------
+
+describe('L19 — same-meta-kind parent constraint', () => {
+  it('POSITIVE: schema:stage under schema:pipeline shares same kind (schema)', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          pipe: {
+            kind: 'schema',
+            type: 'pipeline',
+            label: 'Pipeline',
+            data: { entityId: 'crm.deal' }
+          },
+          stage: {
+            kind: 'schema',
+            type: 'stage',
+            label: 'Stage',
+            parentContentId: 'pipe',
+            data: { semanticClass: 'open' }
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+
+  it('NEGATIVE: registered child under registered parent with different meta-kind produces L19 error', () => {
+    // schema:stage (meta-kind: schema) trying to parent under config:kv (meta-kind: config)
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          'my-config': {
+            kind: 'config',
+            type: 'kv',
+            label: 'Config',
+            data: { entries: { enabled: true } }
+          },
+          'my-stage': {
+            kind: 'schema',
+            type: 'stage',
+            label: 'Stage',
+            parentContentId: 'my-config',
+            data: { semanticClass: 'open' }
+          }
+        }
+      }
+    })
+    const messages = getIssueMessages(data)
+    expect(messages.some((m) => m.includes('same-meta-kind') || m.includes('parentContentId'))).toBe(true)
+  })
+})