@elevasis/core 0.23.0 → 0.24.1

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

@@ -1,210 +1,210 @@
-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 {
+  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)
+  })
+})