@elevasis/core 0.24.1 → 0.26.0

package/src/organization-model/__tests__/content-kinds-registry.test.ts

@@ -1,210 +1,35 @@
-import { describe, expect, it } from 'vitest'
-import {
-  CONTENT_KIND_REGISTRY,
-  defineContentType,
-  lookupContentType,
-  pipelineKind,
-  stageKind,
-  templateKind,
-  templateStepKind,
-  statusFlowKind,
-  statusKind,
-  configKvKind
-} from '../content-kinds/index'
-import type { ContentTypeDefinition, ContentTypeKey } from '../content-kinds/types'
-
-// ---------------------------------------------------------------------------
-// CONTENT_KIND_REGISTRY shape (D8: static object literal)
-// ---------------------------------------------------------------------------
-
-describe('CONTENT_KIND_REGISTRY', () => {
-  it('contains all 7 expected keys', () => {
-    const expectedKeys: ContentTypeKey[] = [
-      'schema:pipeline',
-      'schema:stage',
-      'schema:template',
-      'schema:template-step',
-      'schema:status-flow',
-      'schema:status',
-      'config:kv'
-    ]
-    for (const key of expectedKeys) {
-      expect(CONTENT_KIND_REGISTRY).toHaveProperty(key)
-    }
-  })
-
-  it('maps schema:pipeline to the pipelineKind definition', () => {
-    expect(CONTENT_KIND_REGISTRY['schema:pipeline']).toBe(pipelineKind)
-  })
-
-  it('maps schema:stage to the stageKind definition', () => {
-    expect(CONTENT_KIND_REGISTRY['schema:stage']).toBe(stageKind)
-  })
-
-  it('maps schema:template to the templateKind definition', () => {
-    expect(CONTENT_KIND_REGISTRY['schema:template']).toBe(templateKind)
-  })
-
-  it('maps schema:template-step to the templateStepKind definition', () => {
-    expect(CONTENT_KIND_REGISTRY['schema:template-step']).toBe(templateStepKind)
-  })
-
-  it('maps schema:status-flow to the statusFlowKind definition', () => {
-    expect(CONTENT_KIND_REGISTRY['schema:status-flow']).toBe(statusFlowKind)
-  })
-
-  it('maps schema:status to the statusKind definition', () => {
-    expect(CONTENT_KIND_REGISTRY['schema:status']).toBe(statusKind)
-  })
-
-  it('maps config:kv to the configKvKind definition', () => {
-    expect(CONTENT_KIND_REGISTRY['config:kv']).toBe(configKvKind)
-  })
-
-  it('has exactly 7 keys (no extra unintended entries)', () => {
-    expect(Object.keys(CONTENT_KIND_REGISTRY)).toHaveLength(7)
-  })
-
-  it('every entry has kind, type, payloadSchema, label, and description fields', () => {
-    for (const [key, def] of Object.entries(CONTENT_KIND_REGISTRY)) {
-      expect(def).toHaveProperty('kind')
-      expect(def).toHaveProperty('type')
-      expect(def).toHaveProperty('payloadSchema')
-      expect(typeof def.kind).toBe('string')
-      expect(typeof def.type).toBe('string')
-      expect(def.label).toBeTruthy()
-      expect(def.description).toBeTruthy()
-      // key must equal kind:type
-      expect(key).toBe(`${def.kind}:${def.type}`)
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// parentTypes constraint
-// ---------------------------------------------------------------------------
-
-describe('parentTypes constraints', () => {
-  it('schema:pipeline has empty parentTypes (top-level, no parent required)', () => {
-    expect(pipelineKind.parentTypes).toEqual([])
-  })
-
-  it('schema:stage parentTypes is ["schema:pipeline"]', () => {
-    expect(stageKind.parentTypes).toEqual(['schema:pipeline'])
-  })
-
-  it('schema:template has empty parentTypes', () => {
-    expect(templateKind.parentTypes).toEqual([])
-  })
-
-  it('schema:template-step parentTypes is ["schema:template"]', () => {
-    expect(templateStepKind.parentTypes).toEqual(['schema:template'])
-  })
-
-  it('schema:status-flow has empty parentTypes', () => {
-    expect(statusFlowKind.parentTypes).toEqual([])
-  })
-
-  it('schema:status parentTypes is ["schema:status-flow"]', () => {
-    expect(statusKind.parentTypes).toEqual(['schema:status-flow'])
-  })
-
-  it('config:kv has empty parentTypes', () => {
-    expect(configKvKind.parentTypes).toEqual([])
-  })
-})
-
-// ---------------------------------------------------------------------------
-// lookupContentType
-// ---------------------------------------------------------------------------
-
-describe('lookupContentType', () => {
-  it('returns the correct definition for schema:pipeline', () => {
-    const def = lookupContentType('schema', 'pipeline')
-    expect(def).toBe(pipelineKind)
-  })
-
-  it('returns the correct definition for schema:stage', () => {
-    const def = lookupContentType('schema', 'stage')
-    expect(def).toBe(stageKind)
-  })
-
-  it('returns the correct definition for config:kv', () => {
-    const def = lookupContentType('config', 'kv')
-    expect(def).toBe(configKvKind)
-  })
-
-  it('returns undefined for an unregistered kind (D2: not an error)', () => {
-    const def = lookupContentType('tenant', 'custom-thing')
-    expect(def).toBeUndefined()
-  })
-
-  it('returns undefined for unknown kind with valid type', () => {
-    const def = lookupContentType('unknown', 'pipeline')
-    expect(def).toBeUndefined()
-  })
-
-  it('returns undefined for valid kind with unknown type', () => {
-    const def = lookupContentType('schema', 'not-a-real-type')
-    expect(def).toBeUndefined()
-  })
-
-  it('returns undefined for empty kind string', () => {
-    const def = lookupContentType('', 'pipeline')
-    expect(def).toBeUndefined()
-  })
-
-  it('returns undefined for empty type string', () => {
-    const def = lookupContentType('schema', '')
-    expect(def).toBeUndefined()
-  })
-})
-
-// ---------------------------------------------------------------------------
-// defineContentType (identity factory, L16)
-// ---------------------------------------------------------------------------
-
-describe('defineContentType', () => {
-  it('is an identity function — returns the same object reference', () => {
-    const def: ContentTypeDefinition<{ name: string }> = {
-      kind: 'tenant',
-      type: 'custom',
-      payloadSchema: { safeParse: () => ({ success: true, data: { name: 'x' } }) } as unknown as ContentTypeDefinition<{
-        name: string
-      }>['payloadSchema'],
-      label: 'Custom',
-      description: 'A tenant-defined type.',
-      parentTypes: []
-    }
-    const result = defineContentType(def)
-    expect(result).toBe(def)
-  })
-
-  it('does NOT mutate the input definition', () => {
-    const def: ContentTypeDefinition<unknown> = {
-      kind: 'schema',
-      type: 'pipeline',
-      payloadSchema: {
-        safeParse: () => ({ success: true, data: {} })
-      } as unknown as ContentTypeDefinition<unknown>['payloadSchema'],
-      parentTypes: []
-    }
-    const original = { ...def }
-    defineContentType(def)
-    expect(def).toEqual(original)
-  })
-
-  it('does NOT register the definition globally (no side-effects on CONTENT_KIND_REGISTRY)', () => {
-    const tenantKey = 'tenant:my-new-type'
-    defineContentType({
-      kind: 'tenant',
-      type: 'my-new-type',
-      payloadSchema: {
-        safeParse: () => ({ success: true, data: {} })
-      } as unknown as ContentTypeDefinition<unknown>['payloadSchema'],
-      parentTypes: []
-    })
-    // After calling defineContentType, the registry must remain unchanged (D8: static)
-    expect(CONTENT_KIND_REGISTRY).not.toHaveProperty(tenantKey)
-  })
-})
+import { describe, expect, it } from 'vitest'
+import { OrganizationGraphNodeKindSchema } from '../graph/schema'
+import { OrganizationModelSchema } from '../schema'
+
+describe('retired System.content bridge', () => {
+  it('rejects bridge-era content maps on System entries', () => {
+    const result = OrganizationModelSchema.safeParse({
+      version: 1,
+      branding: { name: 'Test Org' },
+      navigation: { sidebar: [] },
+      systems: {
+        sales: {
+          id: 'sales',
+          order: 10,
+          label: 'Sales',
+          content: {
+            pipeline: {
+              kind: 'schema',
+              type: 'pipeline',
+              label: 'Pipeline',
+              data: { entityId: 'crm.deal' }
+            }
+          }
+        }
+      }
+    })
+
+    expect(result.success).toBe(false)
+    expect(result.error?.issues.map((issue) => issue.path.join('.'))).toContain('systems.sales')
+  })
+
+  it('rejects content-node as a graph node kind', () => {
+    expect(OrganizationGraphNodeKindSchema.safeParse('content-node').success).toBe(false)
+  })
+})

package/src/organization-model/__tests__/defaults.test.ts

@@ -78,7 +78,7 @@ describe('organization-model defaults', () => {
   describe.skip('DEFAULT_ORGANIZATION_MODEL_SALES via resolveOrganizationModel (deferred — Phase 4: sales domain removed)', () => {
     it('resolving with sales override produces a schema-valid model', () => {
       // Previously: resolveOrganizationModel({ sales: DEFAULT_ORGANIZATION_MODEL_SALES })
-      // Sales data now lives in system.content. Use getAllPipelines(model) from migration-helpers.
+      // Sales data now lives in System.ontology.catalogTypes. Use getAllPipelines(model).
     })
   })
 
@@ -86,7 +86,7 @@ describe('organization-model defaults', () => {
   describe.skip('DEFAULT_ORGANIZATION_MODEL_PROJECTS via resolveOrganizationModel (deferred — Phase 4: projects domain removed)', () => {
     it('resolving with projects override produces a schema-valid model', () => {
       // Previously: resolveOrganizationModel({ projects: DEFAULT_ORGANIZATION_MODEL_PROJECTS })
-      // Project statuses now live in system.content. Use getAllProjectStatuses(model) from migration-helpers.
+      // Project statuses now live in System.ontology.catalogTypes. Use getAllProjectStatuses(model).
     })
   })
 
@@ -94,7 +94,7 @@ describe('organization-model defaults', () => {
   describe.skip('DEFAULT_ORGANIZATION_MODEL_PROSPECTING via resolveOrganizationModel (deferred — Phase 4: prospecting domain removed)', () => {
     it('resolving with prospecting override produces a schema-valid model', () => {
       // Previously: resolveOrganizationModel({ prospecting: DEFAULT_ORGANIZATION_MODEL_PROSPECTING })
-      // Prospecting stages/templates now live in system.content. Use getAllProspectingStages() / getAllBuildTemplates().
+      // Prospecting stages/templates now live in System.ontology.catalogTypes.
     })
   })
 
@@ -122,7 +122,7 @@ describe('organization-model defaults', () => {
     // We keep the data-integrity checks below; the resolveOrganizationModel override test is skipped.
     it.skip('resolving with statuses override produces a schema-valid model (deferred — Phase 4: statuses field removed from OM schema)', () => {
       // Previously: resolveOrganizationModel({ statuses: DEFAULT_ORGANIZATION_MODEL_STATUSES })
-      // Status data now lives in system.content via (schema:status-flow) + (schema:status) content nodes.
+      // Status data now lives in System.ontology.catalogTypes.
     })
 
     it('default statuses seed covers all 9 delivery.task values', () => {

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

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest'
+import {
+  getSystemDeprecationDependents,
+  type OrganizationModel,
+  type OmTopologyDomain
+} from '../index'
+
+const model = {
+  systems: {
+    sales: {
+      id: 'sales',
+      order: 1,
+      label: 'Sales',
+      lifecycle: 'active',
+      systems: {
+        crm: {
+          id: 'sales.crm',
+          order: 2,
+          label: 'CRM',
+          lifecycle: 'active'
+        }
+      }
+    }
+  },
+  resources: {
+    'crm-active-workflow': {
+      id: 'crm-active-workflow',
+      order: 1,
+      kind: 'workflow',
+      systemPath: 'sales.crm',
+      status: 'active',
+      codeRefs: []
+    },
+    'crm-archived-workflow': {
+      id: 'crm-archived-workflow',
+      order: 2,
+      kind: 'workflow',
+      systemPath: 'sales.crm',
+      status: 'archived',
+      codeRefs: []
+    }
+  },
+  knowledge: {},
+  topology: {
+    version: 1,
+    relationships: {
+      'crm-active-uses-sales': {
+        from: { kind: 'resource', id: 'crm-active-workflow' },
+        kind: 'uses',
+        to: { kind: 'system', id: 'sales' }
+      },
+      'archived-resource-edge': {
+        from: { kind: 'resource', id: 'crm-archived-workflow' },
+        kind: 'uses',
+        to: { kind: 'system', id: 'sales' }
+      }
+    }
+  } satisfies OmTopologyDomain
+} as OrganizationModel
+
+describe('getSystemDeprecationDependents', () => {
+  it('enumerates active resources and topology edges for a system tree', () => {
+    const dependents = getSystemDeprecationDependents(model, 'sales', { includeDescendants: true })
+
+    expect(dependents.resources.map((resource) => resource.id)).toEqual(['crm-active-workflow'])
+    expect(dependents.topologyEdges.map((edge) => edge.id).sort()).toEqual([
+      'archived-resource-edge',
+      'crm-active-uses-sales'
+    ])
+  })
+})

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

@@ -1,40 +1,16 @@
 import { describe, expect, it } from 'vitest'
-import {
-  ActionsDomainSchema,
-  ActionInvocationSchema,
-  CRM_ACTION_ENTRIES,
-  DEFAULT_ORGANIZATION_MODEL_ACTIONS,
-  LEAD_GEN_ACTION_ENTRIES
-} from '../../domains/actions'
-
-describe('actions domain', () => {
-  it('defaults lead-gen action entries with invocation contracts', () => {
-    const domain = ActionsDomainSchema.parse(LEAD_GEN_ACTION_ENTRIES)
-
-    expect(Object.keys(domain)).toHaveLength(13)
-    expect(domain['lead-gen.company.source']).toMatchObject({
-      id: 'lead-gen.company.source',
-      scope: { domain: 'sales' },
-      lifecycle: 'active'
-    })
-    expect(Object.values(domain).every((action) => action.invocations.length > 0)).toBe(true)
-  })
-
-  it('defaults CRM action entries for deal actions', () => {
-    const domain = ActionsDomainSchema.parse(CRM_ACTION_ENTRIES)
-
-    expect(Object.keys(domain)).toHaveLength(9)
-    expect(domain.mark_no_show).toBeUndefined()
-    expect(
-      Object.values(domain).every((action) => action.affects?.includes('crm.deal') && action.resourceId !== undefined)
-    ).toBe(true)
-  })
-
-  it('defaults all organization-model actions', () => {
-    const domain = ActionsDomainSchema.parse(DEFAULT_ORGANIZATION_MODEL_ACTIONS)
-
-    expect(Object.keys(domain)).toHaveLength(22)
-  })
+import {
+  ActionsDomainSchema,
+  ActionInvocationSchema,
+  DEFAULT_ORGANIZATION_MODEL_ACTIONS
+} from '../../domains/actions'
+
+describe('actions domain', () => {
+  it('keeps the generic core default action catalog empty', () => {
+    const domain = ActionsDomainSchema.parse(DEFAULT_ORGANIZATION_MODEL_ACTIONS)
+
+    expect(domain).toEqual({})
+  })
 
   it('accepts entity references in affects', () => {
     expect(() =>

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

@@ -321,12 +321,19 @@ describe('resolveOrganizationModel — offerings cross-ref (targetSegmentIds)',
 // ---------------------------------------------------------------------------
 
 describe('resolveOrganizationModel — offerings cross-ref (deliveryFeatureId)', () => {
-  it('passes when deliveryFeatureId references a declared system', () => {
-    // 'sales.crm' is in DEFAULT_ORGANIZATION_MODEL.systems
-    expect(() =>
-      resolveOrganizationModel({
-        offerings: {
-          'product-with-delivery': {
+  it('passes when deliveryFeatureId references a declared system', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        systems: {
+          'sales.crm': {
+            id: 'sales.crm',
+            order: 10,
+            label: 'CRM',
+            lifecycle: 'active'
+          }
+        },
+        offerings: {
+          'product-with-delivery': {
             id: 'product-with-delivery',
             order: 10,
             deliveryFeatureId: 'sales.crm'