@elevasis/core 0.24.1 → 0.26.0

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

@@ -1,549 +1,176 @@
-/**
- * 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 { DEFAULT_ORGANIZATION_MODEL_BRANDING } from '../domains/branding'
 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)
+import { resolveOrganizationModel } from '../resolve'
+
+function minimalModel(systems: Record<string, unknown>) {
+  return {
+    version: 1,
+    branding: DEFAULT_ORGANIZATION_MODEL_BRANDING,
+    entities: {},
+    systems
+  }
+}
+
+describe('recursive System schema after System.content retirement', () => {
+  it('parses recursively authored systems with canonical systems children', () => {
+    const model = resolveOrganizationModel(
+      minimalModel({
+        parent: {
+          id: 'parent',
+          order: 10,
+          label: 'Parent',
+          systems: {
+            child: {
+              id: 'parent.child',
+              order: 20,
+              label: 'Child'
+            }
+          }
+        }
+      })
+    )
+
+    expect(model.systems.parent?.systems?.child?.id).toBe('parent.child')
+    expect(model.systems.parent?.subsystems?.child?.id).toBe('parent.child')
   })
 
-  it('parses canonical systems children and keeps subsystems as a compatibility alias', () => {
-    const model = resolveOrganizationModel({
-      systems: {
+  it('keeps subsystems as a compatibility alias for recursive traversal', () => {
+    const model = resolveOrganizationModel(
+      minimalModel({
         parent: {
-          ...makeSystem('parent', '/parent'),
+          id: 'parent',
+          order: 10,
+          label: 'Parent',
+          subsystems: {
+            child: {
+              id: 'parent.child',
+              order: 20,
+              label: 'Child'
+            }
+          }
+        }
+      })
+    )
+
+    expect(model.systems.parent?.subsystems?.child?.id).toBe('parent.child')
+  })
+
+  it('rejects content maps on top-level systems', () => {
+    const result = OrganizationModelSchema.safeParse(
+      minimalModel({
+        dashboard: {
+          id: 'dashboard',
+          order: 10,
+          label: 'Dashboard',
+          content: {
+            pipeline: {
+              kind: 'schema',
+              type: 'pipeline',
+              label: 'Pipeline',
+              data: { entityId: 'crm.deal' }
+            }
+          }
+        }
+      })
+    )
+
+    expect(result.success).toBe(false)
+    const contentIssue = result.error?.issues.find((issue) => issue.path.join('.') === 'systems.dashboard')
+    expect(contentIssue).toMatchObject({
+      code: 'unrecognized_keys',
+      path: ['systems', 'dashboard']
+    })
+  })
+
+  it('rejects content maps on nested systems', () => {
+    const result = OrganizationModelSchema.safeParse(
+      minimalModel({
+        parent: {
+          id: 'parent',
+          order: 10,
+          label: 'Parent',
           systems: {
             child: {
-              ...makeSystem('child', '/parent/child'),
+              id: 'parent.child',
+              order: 20,
+              label: 'Child',
               content: {
-                pipeline: {
-                  kind: 'schema',
-                  type: 'pipeline',
-                  label: 'Pipeline',
-                  data: { entityId: 'crm.deal' }
+                settings: {
+                  kind: 'config',
+                  type: 'kv',
+                  label: 'Settings',
+                  data: { entries: { mode: 'bridge' } }
                 }
               }
             }
           }
         }
-      }
+      })
+    )
+
+    expect(result.success).toBe(false)
+    const contentIssue = result.error?.issues.find((issue) => issue.path.join('.') === 'systems.parent.systems.child')
+    expect(contentIssue).toMatchObject({
+      code: 'unrecognized_keys',
+      path: ['systems', 'parent', 'systems', 'child']
     })
+  })
+
+  it('accepts equivalent catalog authoring in system ontology', () => {
+    const result = OrganizationModelSchema.safeParse(
+      minimalModel({
+        dashboard: {
+          id: 'dashboard',
+          order: 10,
+          label: 'Dashboard',
+          ontology: {
+            objectTypes: {
+              'dashboard:object/deal': {
+                id: 'dashboard:object/deal',
+                label: 'Deal',
+                ownerSystemId: 'dashboard'
+              }
+            },
+            catalogTypes: {
+              'dashboard:catalog/pipeline': {
+                id: 'dashboard:catalog/pipeline',
+                label: 'Pipeline',
+                kind: 'pipeline',
+                appliesTo: 'dashboard:object/deal',
+                entries: {
+                  open: { label: 'Open', order: 10, semanticClass: 'open' }
+                }
+              }
+            }
+          }
+        }
+      })
+    )
+
+    expect(result.success).toBe(true)
+  })
 
-    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')
+  it('accepts equivalent local settings in first-class system config', () => {
+    const model = resolveOrganizationModel(
+      minimalModel({
+        dashboard: {
+          id: 'dashboard',
+          order: 10,
+          label: 'Dashboard',
+          config: {
+            mode: 'direct',
+            retries: 3,
+            nested: { enabled: true }
+          }
+        }
+      })
+    )
+
+    expect(model.systems.dashboard?.config).toEqual({
+      mode: 'direct',
+      retries: 3,
+      nested: { enabled: true }
+    })
   })
 })
-
-// ---------------------------------------------------------------------------
-// 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)
-  })
-})