@beechcms/cli 0.6.0-preview.1 → 0.6.0-preview.3

package/src/test/validate.test.ts

@@ -0,0 +1,261 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { validateSeeds, validate } from '../commands/validate.js'
+import type { Seed } from '@beechcms/core'
+
+type PartialBranch = Omit<Seed['branches'][number], 'id'>
+
+function makeSeed(slug: string, branches: PartialBranch[] = []): Seed {
+  let counter = 0
+  const withIds = (branches.length > 0 ? branches : [{ alias: 'title', label: 'Title', type: 'text' }])
+    .map(b => ({ id: `br_${String(++counter).padStart(2, '0')}`, ...b }))
+  return {
+    slug,
+    label: slug,
+    displayNameAlias: withIds[0]?.alias ?? 'title',
+    branches: withIds,
+  } as Seed
+}
+
+// ── Unknown relation target ────────────────────────────────────────────────
+
+describe('validateSeeds — unknown relation target', () => {
+  it('emits a fatal error when targetSeed not in registry', () => {
+    const registry = {
+      articles: makeSeed('articles', [
+        { alias: 'title', label: 'Title', type: 'text' },
+        { alias: 'author_id', label: 'Author', type: 'relation', targetSeed: 'team' },
+      ]),
+    }
+
+    const errors = validateSeeds(registry as Record<string, Seed>)
+    const fatal = errors.filter(e => e.fatal)
+
+    expect(fatal).toHaveLength(1)
+    expect(fatal[0].slug).toBe('articles')
+    expect(fatal[0].messages[0]).toContain('author_id')
+    expect(fatal[0].messages[0]).toContain('team')
+  })
+
+  it('no fatal error when targetSeed is in registry', () => {
+    const registry = {
+      team: makeSeed('team', [{ alias: 'name', label: 'Name', type: 'text' }]),
+      articles: makeSeed('articles', [
+        { alias: 'title', label: 'Title', type: 'text' },
+        { alias: 'author_id', label: 'Author', type: 'relation', targetSeed: 'team' },
+      ]),
+    }
+
+    const errors = validateSeeds(registry as Record<string, Seed>)
+    const fatal = errors.filter(e => e.fatal)
+    expect(fatal).toHaveLength(0)
+  })
+})
+
+// ── Cyclic dependency ─────────────────────────────────────────────────────
+
+describe('validateSeeds — cyclic dependency', () => {
+  it('emits a fatal error listing both slugs in a cycle', () => {
+    const registry = {
+      a: {
+        slug: 'a',
+        label: 'A',
+        displayNameAlias: 'title',
+        branches: [
+          { id: 'br_01', alias: 'title', label: 'Title', type: 'text' },
+          { id: 'br_02', alias: 'b_id', label: 'B', type: 'relation', targetSeed: 'b' },
+        ],
+      },
+      b: {
+        slug: 'b',
+        label: 'B',
+        displayNameAlias: 'title',
+        branches: [
+          { id: 'br_01', alias: 'title', label: 'Title', type: 'text' },
+          { id: 'br_02', alias: 'a_id', label: 'A', type: 'relation', targetSeed: 'a' },
+        ],
+      },
+    }
+
+    const errors = validateSeeds(registry as Record<string, Seed>)
+    const fatal = errors.filter(e => e.fatal)
+
+    // One fatal entry for the cycle
+    expect(fatal.length).toBeGreaterThan(0)
+    const cycleMsg = fatal.find(e => e.messages.some(m => m.includes('Cyclic')))
+    expect(cycleMsg).toBeDefined()
+    expect(cycleMsg!.messages[0]).toContain('a')
+    expect(cycleMsg!.messages[0]).toContain('b')
+  })
+})
+
+// ── Multi-relation: SET NULL rejection ───────────────────────────────────────
+
+describe('validateSeeds — multi-relation SET NULL', () => {
+  it('emits a fatal error when multiple: true + onDelete: SET NULL', () => {
+    const registry = {
+      tag: makeSeed('tag'),
+      articles: makeSeed('articles', [
+        { alias: 'title', label: 'Title', type: 'text' },
+        {
+          alias: 'tags',
+          label: 'Tags',
+          type: 'relation',
+          targetSeed: 'tag',
+          multiple: true,
+          onDelete: 'SET NULL',
+        },
+      ]),
+    }
+
+    const errors = validateSeeds(registry as Record<string, Seed>)
+    const fatal = errors.filter(e => e.fatal)
+    expect(fatal.length).toBeGreaterThan(0)
+    const tagError = fatal.find(e => e.slug === 'articles')
+    expect(tagError).toBeDefined()
+    expect(tagError!.messages[0]).toContain("'tags'")
+    expect(tagError!.messages[0]).toContain('SET NULL')
+  })
+
+  it('does not error for multiple: true + onDelete: CASCADE', () => {
+    const registry = {
+      tag: makeSeed('tag'),
+      articles: makeSeed('articles', [
+        { alias: 'title', label: 'Title', type: 'text' },
+        {
+          alias: 'tags',
+          label: 'Tags',
+          type: 'relation',
+          targetSeed: 'tag',
+          multiple: true,
+          onDelete: 'CASCADE',
+        },
+      ]),
+    }
+
+    const errors = validateSeeds(registry as Record<string, Seed>)
+    const setNullErrors = errors.filter(e => e.fatal && e.messages.some(m => m.includes('SET NULL')))
+    expect(setNullErrors).toHaveLength(0)
+  })
+
+  it('does not error for multiple: true with no onDelete (defaults to CASCADE)', () => {
+    const registry = {
+      tag: makeSeed('tag'),
+      articles: makeSeed('articles', [
+        { alias: 'title', label: 'Title', type: 'text' },
+        { alias: 'tags', label: 'Tags', type: 'relation', targetSeed: 'tag', multiple: true },
+      ]),
+    }
+
+    const errors = validateSeeds(registry as Record<string, Seed>)
+    const fatal = errors.filter(e => e.fatal)
+    expect(fatal).toHaveLength(0)
+  })
+})
+
+// ── Multi-relation: junction table name collision ─────────────────────────────
+
+describe('validateSeeds — junction table name collision', () => {
+  it('emits fatal error when two branches produce the same junction table name', () => {
+    // 'rel_articles_tags' collides if somehow two branches have the same alias
+    // This is prevented by duplicate alias check, but the junction collision check
+    // handles cross-seed collisions after truncation.
+    const registry = {
+      tag: makeSeed('tag'),
+      // Simulate a collision: same junction name from different seeds
+      rel_articles: makeSeed('rel_articles', [
+        { alias: 'title', label: 'T', type: 'text' },
+        { alias: 'tags', label: 'Tags', type: 'relation', targetSeed: 'tag', multiple: true },
+      ]),
+      articles: makeSeed('articles', [
+        { alias: 'title', label: 'T', type: 'text' },
+        // slug='articles' + alias='rel_articles_tags' → 'rel_articles_rel_articles_tags'
+        // Use a manually crafted collision scenario:
+        { alias: 'tags', label: 'Tags', type: 'relation', targetSeed: 'tag', multiple: true },
+      ]),
+    }
+    // These won't collide but the rule should run without errors
+    const errors = validateSeeds(registry as Record<string, Seed>)
+    const collisionErrors = errors.filter(e => e.fatal && e.messages.some(m => m.includes('collision')))
+    expect(collisionErrors).toHaveLength(0)
+  })
+})
+
+// ── Existing warning checks still work ────────────────────────────────────
+
+describe('validateSeeds — existing warning checks', () => {
+  it('flags missing displayNameAlias as warning (not fatal)', () => {
+    const registry = {
+      items: {
+        slug: 'items',
+        label: 'Items',
+        displayNameAlias: 'nonexistent',
+        branches: [{ id: 'br_01', alias: 'title', label: 'Title', type: 'text' }],
+      },
+    }
+
+    const errors = validateSeeds(registry as Record<string, Seed>)
+    const warnings = errors.filter(e => !e.fatal)
+    expect(warnings.length).toBeGreaterThan(0)
+    expect(warnings[0].messages[0]).toContain('displayNameAlias')
+  })
+})
+
+describe('validate CLI command wrapper', () => {
+  let logSpy: any
+  let warnSpy: any
+  let exitSpy: any
+
+  beforeEach(() => {
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as any)
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('warns when registry is empty', async () => {
+    await validate({ registry: {} })
+    expect(warnSpy).toHaveBeenCalled()
+    expect(warnSpy.mock.calls[0][0]).toContain('SEED_REGISTRY is empty')
+  })
+
+  it('logs success when all seeds are valid', async () => {
+    const registry = {
+      articles: makeSeed('articles'),
+    }
+    await validate({ registry })
+    expect(logSpy).toHaveBeenCalled()
+    expect(logSpy.mock.calls.some((c: any[]) => c[0].includes('All seeds valid'))).toBe(true)
+  })
+
+  it('logs warnings when seeds have non-fatal issues', async () => {
+    const registry = {
+      items: {
+        slug: 'items',
+        label: 'Items',
+        displayNameAlias: 'nonexistent',
+        branches: [{ id: 'br_01', alias: 'title', label: 'Title', type: 'text' }],
+      },
+    }
+    await validate({ registry: registry as any })
+    expect(logSpy).toHaveBeenCalled()
+    expect(logSpy.mock.calls.some((c: any[]) => c[0].includes('Found 1 warning'))).toBe(true)
+  })
+
+  it('exits with 1 when seeds have fatal errors', async () => {
+    const registry = {
+      articles: makeSeed('articles', [
+        { alias: 'title', label: 'Title', type: 'text' },
+        { alias: 'author_id', label: 'Author', type: 'relation', targetSeed: 'team' },
+      ]),
+    }
+    await validate({ registry: registry as any })
+    expect(exitSpy).toHaveBeenCalledWith(1)
+  })
+})
+

package/tsconfig.json

@@ -1,16 +1,16 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "composite": true,
-    "declaration": true,
-    "declarationMap": true,
-    "outDir": "dist",
-    "rootDir": "src",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "target": "ES2022"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"],
-  "references": [{ "path": "../core" }]
-}
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "composite": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "target": "ES2022"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"],
+  "references": [{ "path": "../core" }]
+}