@elevasis/core 0.23.0 → 0.24.0

package/src/scaffold-registry/__tests__/schema.test.ts

@@ -1,26 +1,26 @@
-import { describe, expect, it } from 'vitest'
-import {
-  ExternalSyncCategorySchema,
-  ExternalSyncDeletePolicySchema,
-  ExternalSyncOwnerSchema,
-  ExternalSyncStrategySchema,
-  ScaffoldEntryKindSchema,
-  ScaffoldRegistryEntrySchema,
-  ScaffoldRegistrySchema
-} from '../schema'
+import { describe, expect, it } from 'vitest'
+import {
+  ExternalSyncCategorySchema,
+  ExternalSyncDeletePolicySchema,
+  ExternalSyncOwnerSchema,
+  ExternalSyncStrategySchema,
+  ScaffoldEntryKindSchema,
+  ScaffoldRegistryEntrySchema,
+  ScaffoldRegistrySchema
+} from '../schema'
 
 // ---------------------------------------------------------------------------
 // Kind enum
 // ---------------------------------------------------------------------------
 
-describe('ScaffoldEntryKindSchema', () => {
+describe('ScaffoldEntryKindSchema', () => {
   it('accepts all declared kinds', () => {
     const validKinds = [
       'autogen',
       'manual-scaffold',
-      'sync-preservation',
-      'validator',
-      'other'
+      'sync-preservation',
+      'validator',
+      'other'
     ]
     for (const kind of validKinds) {
       expect(ScaffoldEntryKindSchema.safeParse(kind).success).toBe(true)
@@ -34,47 +34,47 @@ describe('ScaffoldEntryKindSchema', () => {
 
   it('rejects empty string', () => {
     expect(ScaffoldEntryKindSchema.safeParse('').success).toBe(false)
-  })
-})
-
-describe('External sync enums', () => {
-  it('accepts all declared external sync categories', () => {
-    for (const category of ['replace', 'merge', 'never-touch', 'generated']) {
-      expect(ExternalSyncCategorySchema.safeParse(category).success).toBe(true)
-    }
-  })
-
-  it('accepts all declared external sync owners', () => {
-    for (const owner of ['template', '@elevasis/ui', '@elevasis/core', '@elevasis/sdk', 'generator', 'project']) {
-      expect(ExternalSyncOwnerSchema.safeParse(owner).success).toBe(true)
-    }
-  })
-
-  it('accepts all declared external sync strategies', () => {
-    for (const strategy of [
-      'replace-all',
-      'merge-regions',
-      'merge-baseline',
-      'verify-only',
-      'generated-freshness'
-    ]) {
-      expect(ExternalSyncStrategySchema.safeParse(strategy).success).toBe(true)
-    }
-  })
-
-  it('accepts all declared external sync delete policies', () => {
-    for (const deletePolicy of ['none', 'manifest-only']) {
-      expect(ExternalSyncDeletePolicySchema.safeParse(deletePolicy).success).toBe(true)
-    }
-  })
-
-  it('rejects unknown external sync enum values', () => {
-    expect(ExternalSyncCategorySchema.safeParse('rewrite').success).toBe(false)
-    expect(ExternalSyncOwnerSchema.safeParse('packages/core').success).toBe(false)
-    expect(ExternalSyncStrategySchema.safeParse('replace-some').success).toBe(false)
-    expect(ExternalSyncDeletePolicySchema.safeParse('delete-all').success).toBe(false)
-  })
-})
+  })
+})
+
+describe('External sync enums', () => {
+  it('accepts all declared external sync categories', () => {
+    for (const category of ['replace', 'merge', 'never-touch', 'generated']) {
+      expect(ExternalSyncCategorySchema.safeParse(category).success).toBe(true)
+    }
+  })
+
+  it('accepts all declared external sync owners', () => {
+    for (const owner of ['template', '@elevasis/ui', '@elevasis/core', '@elevasis/sdk', 'generator', 'project']) {
+      expect(ExternalSyncOwnerSchema.safeParse(owner).success).toBe(true)
+    }
+  })
+
+  it('accepts all declared external sync strategies', () => {
+    for (const strategy of [
+      'replace-all',
+      'merge-regions',
+      'merge-baseline',
+      'verify-only',
+      'generated-freshness'
+    ]) {
+      expect(ExternalSyncStrategySchema.safeParse(strategy).success).toBe(true)
+    }
+  })
+
+  it('accepts all declared external sync delete policies', () => {
+    for (const deletePolicy of ['none', 'manifest-only']) {
+      expect(ExternalSyncDeletePolicySchema.safeParse(deletePolicy).success).toBe(true)
+    }
+  })
+
+  it('rejects unknown external sync enum values', () => {
+    expect(ExternalSyncCategorySchema.safeParse('rewrite').success).toBe(false)
+    expect(ExternalSyncOwnerSchema.safeParse('packages/core').success).toBe(false)
+    expect(ExternalSyncStrategySchema.safeParse('replace-some').success).toBe(false)
+    expect(ExternalSyncDeletePolicySchema.safeParse('delete-all').success).toBe(false)
+  })
+})
 
 // ---------------------------------------------------------------------------
 // Valid full entry
@@ -88,8 +88,8 @@ const validEntry = {
   dependents: [
     {
       path: '.navigation/_generated/skeleton.md',
-      regen: 'pnpm navigation:generate',
-      hint: 'Regenerate after rename.'
+      regen: 'pnpm navigation:generate',
+      hint: 'Regenerate after rename.'
     }
   ]
 }
@@ -163,77 +163,77 @@ describe('ScaffoldRegistryEntrySchema — valid entry', () => {
     expect(ScaffoldRegistryEntrySchema.safeParse(withAutoRegen).success).toBe(true)
   })
 
-  it('accepts entry without auto_regen (optional)', () => {
-    expect(ScaffoldRegistryEntrySchema.safeParse(validEntry).success).toBe(true)
-  })
-
-  it('rejects auto_regen as a non-boolean', () => {
+  it('accepts entry without auto_regen (optional)', () => {
+    expect(ScaffoldRegistryEntrySchema.safeParse(validEntry).success).toBe(true)
+  })
+
+  it('rejects auto_regen as a non-boolean', () => {
     const withBadAutoRegen = { ...validEntry, auto_regen: 'yes' }
     expect(ScaffoldRegistryEntrySchema.safeParse(withBadAutoRegen).success).toBe(false)
   })
 
-  it('parses all seed-entry kinds with required invariants', () => {
-    const entries = [
-      { ...validEntry, kind: 'autogen', regen: 'pnpm navigation:generate' },
-      { ...validEntry, kind: 'manual-scaffold' },
-      {
-        ...validEntry,
-        kind: 'sync-preservation',
-        owner: 'template',
-        category: 'replace',
-        strategy: 'replace-all',
-        delete_policy: 'none'
-      },
-      { ...validEntry, kind: 'validator', dependents: [{ path: '(self)', regen: 'pnpm meta:verify' }] },
-      { ...validEntry, kind: 'other', notes: 'Vendor generated.' }
-    ]
-    for (const entry of entries) {
-      const result = ScaffoldRegistryEntrySchema.safeParse(entry)
-      const kind = entry.kind
-      expect(result.success, `kind ${kind} should parse`).toBe(true)
-    }
-  })
-
-  it('accepts optional external sync fields for external-sync-aware entries', () => {
-    const withExternalSyncFields = {
-      ...validEntry,
-      owner: 'template',
-      category: 'replace',
-      strategy: 'replace-all',
-      delete_policy: 'manifest-only'
-    }
-    const result = ScaffoldRegistryEntrySchema.safeParse(withExternalSyncFields)
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.category).toBe('replace')
-      expect(result.data.strategy).toBe('replace-all')
-      expect(result.data.delete_policy).toBe('manifest-only')
-    }
-  })
-
-  it('rejects autogen entries without top-level regen', () => {
-    const result = ScaffoldRegistryEntrySchema.safeParse({ ...validEntry, kind: 'autogen' })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects other entries without notes', () => {
-    const result = ScaffoldRegistryEntrySchema.safeParse({ ...validEntry, kind: 'other' })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects sync-preservation entries without external sync metadata', () => {
-    const result = ScaffoldRegistryEntrySchema.safeParse({ ...validEntry, kind: 'sync-preservation' })
-    expect(result.success).toBe(false)
-  })
-
-  it('keeps legacy free-form owner values valid when external sync fields are omitted', () => {
-    const result = ScaffoldRegistryEntrySchema.safeParse({
-      ...validEntry,
-      owner: 'packages/core'
-    })
-    expect(result.success).toBe(true)
-  })
-})
+  it('parses all seed-entry kinds with required invariants', () => {
+    const entries = [
+      { ...validEntry, kind: 'autogen', regen: 'pnpm navigation:generate' },
+      { ...validEntry, kind: 'manual-scaffold' },
+      {
+        ...validEntry,
+        kind: 'sync-preservation',
+        owner: 'template',
+        category: 'replace',
+        strategy: 'replace-all',
+        delete_policy: 'none'
+      },
+      { ...validEntry, kind: 'validator', dependents: [{ path: '(self)', regen: 'pnpm meta:verify' }] },
+      { ...validEntry, kind: 'other', notes: 'Vendor generated.' }
+    ]
+    for (const entry of entries) {
+      const result = ScaffoldRegistryEntrySchema.safeParse(entry)
+      const kind = entry.kind
+      expect(result.success, `kind ${kind} should parse`).toBe(true)
+    }
+  })
+
+  it('accepts optional external sync fields for external-sync-aware entries', () => {
+    const withExternalSyncFields = {
+      ...validEntry,
+      owner: 'template',
+      category: 'replace',
+      strategy: 'replace-all',
+      delete_policy: 'manifest-only'
+    }
+    const result = ScaffoldRegistryEntrySchema.safeParse(withExternalSyncFields)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.category).toBe('replace')
+      expect(result.data.strategy).toBe('replace-all')
+      expect(result.data.delete_policy).toBe('manifest-only')
+    }
+  })
+
+  it('rejects autogen entries without top-level regen', () => {
+    const result = ScaffoldRegistryEntrySchema.safeParse({ ...validEntry, kind: 'autogen' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects other entries without notes', () => {
+    const result = ScaffoldRegistryEntrySchema.safeParse({ ...validEntry, kind: 'other' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects sync-preservation entries without external sync metadata', () => {
+    const result = ScaffoldRegistryEntrySchema.safeParse({ ...validEntry, kind: 'sync-preservation' })
+    expect(result.success).toBe(false)
+  })
+
+  it('keeps legacy free-form owner values valid when external sync fields are omitted', () => {
+    const result = ScaffoldRegistryEntrySchema.safeParse({
+      ...validEntry,
+      owner: 'packages/core'
+    })
+    expect(result.success).toBe(true)
+  })
+})
 
 // ---------------------------------------------------------------------------
 // Invalid entries — required fields missing
@@ -304,38 +304,38 @@ describe('ScaffoldRegistryEntrySchema — invalid entries', () => {
     expect(ScaffoldRegistryEntrySchema.safeParse(withBadCooldown).success).toBe(false)
   })
 
-  it('rejects non-integer cooldown_ms', () => {
-    const withBadCooldown = { ...validEntry, cooldown_ms: 300.5 }
-    expect(ScaffoldRegistryEntrySchema.safeParse(withBadCooldown).success).toBe(false)
-  })
-
-  it('rejects invalid external sync category', () => {
-    const withBadCategory = { ...validEntry, owner: 'template', category: 'rewrite' }
-    expect(ScaffoldRegistryEntrySchema.safeParse(withBadCategory).success).toBe(false)
-  })
-
-  it('rejects invalid external sync strategy', () => {
-    const withBadStrategy = { ...validEntry, owner: 'template', strategy: 'replace-some' }
-    expect(ScaffoldRegistryEntrySchema.safeParse(withBadStrategy).success).toBe(false)
-  })
-
-  it('rejects invalid external sync delete policy', () => {
-    const withBadDeletePolicy = { ...validEntry, owner: 'template', delete_policy: 'delete-all' }
-    expect(ScaffoldRegistryEntrySchema.safeParse(withBadDeletePolicy).success).toBe(false)
-  })
-
-  it('rejects legacy owner strings when external sync metadata is present', () => {
-    const withLegacyOwner = {
-      ...validEntry,
-      owner: 'external/_template',
-      category: 'replace',
-      strategy: 'replace-all',
-      delete_policy: 'manifest-only'
-    }
-    const result = ScaffoldRegistryEntrySchema.safeParse(withLegacyOwner)
-    expect(result.success).toBe(false)
-  })
-})
+  it('rejects non-integer cooldown_ms', () => {
+    const withBadCooldown = { ...validEntry, cooldown_ms: 300.5 }
+    expect(ScaffoldRegistryEntrySchema.safeParse(withBadCooldown).success).toBe(false)
+  })
+
+  it('rejects invalid external sync category', () => {
+    const withBadCategory = { ...validEntry, owner: 'template', category: 'rewrite' }
+    expect(ScaffoldRegistryEntrySchema.safeParse(withBadCategory).success).toBe(false)
+  })
+
+  it('rejects invalid external sync strategy', () => {
+    const withBadStrategy = { ...validEntry, owner: 'template', strategy: 'replace-some' }
+    expect(ScaffoldRegistryEntrySchema.safeParse(withBadStrategy).success).toBe(false)
+  })
+
+  it('rejects invalid external sync delete policy', () => {
+    const withBadDeletePolicy = { ...validEntry, owner: 'template', delete_policy: 'delete-all' }
+    expect(ScaffoldRegistryEntrySchema.safeParse(withBadDeletePolicy).success).toBe(false)
+  })
+
+  it('rejects legacy owner strings when external sync metadata is present', () => {
+    const withLegacyOwner = {
+      ...validEntry,
+      owner: 'external/_template',
+      category: 'replace',
+      strategy: 'replace-all',
+      delete_policy: 'manifest-only'
+    }
+    const result = ScaffoldRegistryEntrySchema.safeParse(withLegacyOwner)
+    expect(result.success).toBe(false)
+  })
+})
 
 // ---------------------------------------------------------------------------
 // Top-level registry document
@@ -386,16 +386,16 @@ describe('ScaffoldRegistrySchema', () => {
           sources: ['apps/docs/content/docs/**/meta.json'],
           dependents: [{ path: '(self)', regen: 'pnpm check-docs-meta' }]
         },
-        {
-          id: 'external-template-hook-added',
-          kind: 'sync-preservation',
-          owner: 'template',
-          category: 'replace',
-          strategy: 'replace-all',
-          delete_policy: 'none',
-          sources: ['external/_template/.claude/hooks/*.mjs'],
-          dependents: [{ path: 'external/_template/.claude/settings.json', regen: 'manual' }]
-        }
+        {
+          id: 'external-template-hook-added',
+          kind: 'sync-preservation',
+          owner: 'template',
+          category: 'replace',
+          strategy: 'replace-all',
+          delete_policy: 'none',
+          sources: ['external/_template/.claude/hooks/*.mjs'],
+          dependents: [{ path: 'external/_template/.claude/settings.json', regen: 'manual' }]
+        }
       ]
     }
     const result = ScaffoldRegistrySchema.safeParse(multiEntry)