@beechcms/cli 0.6.0-preview.2 → 0.6.0-preview.4

package/src/test/seed-load.test.ts

@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { sortSeedsByDependencies } from '@beechcms/core'
+import type { Seed } from '@beechcms/core'
+import { sqlQuote } from '../lib/wrangler.js'
+import { buildSeedRegistrationSql } from '../commands/seed-load.js'
+
+// These seeds declare articles BEFORE team (arbitrary user order in seed.ts)
+const TEAM_SEED: Seed = {
+  slug: 'team',
+  label: 'Team',
+  displayNameAlias: 'name',
+  branches: [{ alias: 'name', label: 'Name', type: 'text' }],
+} as Seed
+
+const ARTICLES_SEED: Seed = {
+  slug: 'articles',
+  label: 'Articles',
+  displayNameAlias: 'title',
+  branches: [
+    { alias: 'title', label: 'Title', type: 'text' },
+    { alias: 'author_id', label: 'Author', type: 'relation', targetSeed: 'team' },
+  ],
+} as Seed
+
+describe('sortSeedsByDependencies — topological ordering', () => {
+  it('puts team before articles even when articles is declared first', () => {
+    // articles declared first — arbitrary insertion order
+    const sorted = sortSeedsByDependencies([ARTICLES_SEED, TEAM_SEED])
+    const slugs = sorted.map(s => s.slug)
+    expect(slugs.indexOf('team')).toBeLessThan(slugs.indexOf('articles'))
+  })
+
+  it('preserves order for seeds with no relations', () => {
+    const a = { slug: 'a', label: 'A', displayNameAlias: 'x', branches: [{ alias: 'x', label: 'X', type: 'text' }] } as Seed
+    const b = { slug: 'b', label: 'B', displayNameAlias: 'x', branches: [{ alias: 'x', label: 'X', type: 'text' }] } as Seed
+    const sorted = sortSeedsByDependencies([a, b])
+    expect(sorted).toHaveLength(2)
+  })
+
+  it('throws on unknown targetSeed', () => {
+    const bad: Seed = {
+      slug: 'bad',
+      label: 'Bad',
+      displayNameAlias: 'title',
+      branches: [
+        { alias: 'title', label: 'Title', type: 'text' },
+        { alias: 'ref_id', label: 'Ref', type: 'relation', targetSeed: 'ghost' },
+      ],
+    } as Seed
+    expect(() => sortSeedsByDependencies([bad])).toThrow(/unknown target|ghost/)
+  })
+
+  it('throws on cyclic graph', () => {
+    const a = {
+      slug: 'a', label: 'A', displayNameAlias: 'x',
+      branches: [
+        { alias: 'x', label: 'X', type: 'text' },
+        { alias: 'b_id', label: 'B', type: 'relation', targetSeed: 'b' },
+      ],
+    } as Seed
+    const b = {
+      slug: 'b', label: 'B', displayNameAlias: 'x',
+      branches: [
+        { alias: 'x', label: 'X', type: 'text' },
+        { alias: 'a_id', label: 'A', type: 'relation', targetSeed: 'a' },
+      ],
+    } as Seed
+    expect(() => sortSeedsByDependencies([a, b])).toThrow(/[Cc]ycl/)
+  })
+})
+
+// ── sqlQuote ─────────────────────────────────────────────────────────────
+
+describe('sqlQuote', () => {
+  it('wraps value in single quotes', () => {
+    expect(sqlQuote('hello')).toBe("'hello'")
+  })
+
+  it("escapes internal single quotes by doubling them", () => {
+    expect(sqlQuote("it's")).toBe("'it''s'")
+  })
+
+  it('handles multiple single quotes', () => {
+    expect(sqlQuote("a'b'c")).toBe("'a''b''c'")
+  })
+
+  it('handles empty string', () => {
+    expect(sqlQuote('')).toBe("''")
+  })
+})
+
+// ── buildSeedRegistrationSql ─────────────────────────────────────────────
+
+describe('buildSeedRegistrationSql', () => {
+  const SIMPLE_SEED: Seed = {
+    slug: 'posts',
+    label: 'Posts',
+    displayNameAlias: 'title',
+    branches: [{ id: 'br_01', alias: 'title', label: 'Title', type: 'text' }],
+  } as Seed
+
+  it('produces INSERT … ON CONFLICT for the correct slug', () => {
+    const sql = buildSeedRegistrationSql(SIMPLE_SEED)
+    expect(sql).toContain("INSERT INTO seeds")
+    expect(sql).toContain("ON CONFLICT(slug) DO UPDATE SET")
+    expect(sql).toContain("'posts'")
+  })
+
+  it("sets source to 'code'", () => {
+    const sql = buildSeedRegistrationSql(SIMPLE_SEED)
+    expect(sql).toContain("'code'")
+  })
+
+  it('escapes single quotes in slug and JSON literal', () => {
+    const seedWithApostrophe: Seed = {
+      ...SIMPLE_SEED,
+      slug: "it's",
+      label: "It's",
+    }
+    const sql = buildSeedRegistrationSql(seedWithApostrophe)
+    // Slug value must have its single quote doubled
+    expect(sql).toContain("'it''s'")
+    // JSON label must also have its single quote doubled
+    expect(sql).toContain("It''s")
+  })
+
+  it('does not contain unescaped single quotes inside the JSON literal', () => {
+    const sql = buildSeedRegistrationSql(SIMPLE_SEED)
+    const jsonStart = sql.indexOf("VALUES (")
+    const jsonPart = sql.slice(jsonStart)
+    // Extract the JSON literal between the second pair of outer quotes
+    // Verify it round-trips back to the original seed
+    const inner = JSON.stringify(SIMPLE_SEED).replace(/'/g, "''")
+    expect(sql).toContain(inner)
+  })
+})
+
+// ── Dry-run output ordering ───────────────────────────────────────────────
+// Verify that seed-load uses sortSeedsByDependencies (not Object.values order)
+// by testing the pure function behavior that underpins it.
+
+describe('seed-load dry-run ordering contract', () => {
+  it('content_team CREATE TABLE appears before content_articles when articles declared first', () => {
+    // The dry-run loops over sortSeedsByDependencies(Object.values(registry)).
+    // We verify the sort result here — the integration is in seed-load.ts.
+    const registry = {
+      articles: ARTICLES_SEED, // declared first
+      team: TEAM_SEED,
+    }
+    const sorted = sortSeedsByDependencies(Object.values(registry))
+    const slugs = sorted.map(s => s.slug)
+    // team must come first so its CREATE TABLE is emitted before articles'
+    expect(slugs.indexOf('team')).toBeLessThan(slugs.indexOf('articles'))
+  })
+})

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" }]
+}