@beechcms/cli 0.6.0-preview.4 → 0.6.0

package/src/test/reset.test.ts

@@ -1,128 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2024–2026 Flavio De Musso
-
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { reset } from '../commands/reset.js'
-import { spawnSync } from 'node:child_process'
-import { existsSync } from 'node:fs'
-
-vi.mock('node:child_process', () => ({
-  spawnSync: vi.fn(() => ({ status: 0 })),
-}))
-
-vi.mock('node:fs', () => ({
-  existsSync: vi.fn(),
-  rmSync: vi.fn(),
-  readFileSync: vi.fn(() => '{}'),
-}))
-
-vi.mock('picocolors', () => ({
-  default: {
-    cyan: (s: string) => s,
-    dim: (s: string) => s,
-    green: (s: string) => s,
-    red: (s: string) => s,
-    yellow: (s: string) => s,
-  },
-}))
-
-describe('reset command', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    vi.mocked(spawnSync).mockImplementation(() => ({ status: 0 } as any))
-  })
-
-  it('runs docker compose down when --docker is passed and docker is running', async () => {
-    await reset({ docker: true })
-    expect(spawnSync).toHaveBeenCalledWith(
-      'docker',
-      ['compose', 'down', '-v'],
-      expect.any(Object)
-    )
-  })
-
-  it('does not run docker compose down when docker is not installed', async () => {
-    // Mock docker --version to fail
-    vi.mocked(spawnSync).mockImplementation((cmd: string, args?: any) => {
-      if (cmd === 'docker' && args && args[0] === '--version') {
-        return { status: 1 } as any
-      }
-      return { status: 0 } as any
-    })
-
-    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never)
-    try {
-      await reset({ docker: true })
-      expect(spawnSync).not.toHaveBeenCalledWith(
-        'docker',
-        ['compose', 'down', '-v'],
-        expect.any(Object)
-      )
-      expect(mockExit).toHaveBeenCalledWith(1)
-    } finally {
-      mockExit.mockRestore()
-    }
-  })
-
-  it('does not run docker compose down when docker daemon is not running', async () => {
-    // Mock docker info to fail
-    vi.mocked(spawnSync).mockImplementation((cmd: string, args?: any) => {
-      if (cmd === 'docker' && args && args[0] === 'info') {
-        return { status: 1 } as any
-      }
-      return { status: 0 } as any
-    })
-
-    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never)
-    try {
-      await reset({ docker: true })
-      expect(spawnSync).not.toHaveBeenCalledWith(
-        'docker',
-        ['compose', 'down', '-v'],
-        expect.any(Object)
-      )
-      expect(mockExit).toHaveBeenCalledWith(1)
-    } finally {
-      mockExit.mockRestore()
-    }
-  })
-
-  it('runs db reset using npm script when apps/api has package.json', async () => {
-    vi.mocked(existsSync).mockImplementation((path: any) => {
-      if (typeof path === 'string' && path.includes('apps') && path.includes('package.json')) {
-        return true
-      }
-      return false
-    })
-
-    await reset({ db: true })
-    expect(spawnSync).toHaveBeenCalledWith(
-      'npm',
-      ['run', 'db:reset:local'],
-      expect.objectContaining({
-        cwd: expect.stringMatching(/apps[/\\]api/),
-      })
-    )
-  })
-
-  it('runs both docker and db when --all is passed', async () => {
-    vi.mocked(existsSync).mockImplementation((path: any) => {
-      if (typeof path === 'string' && path.includes('apps') && path.includes('package.json')) {
-        return true
-      }
-      return false
-    })
-
-    await reset({ all: true })
-    expect(spawnSync).toHaveBeenCalledWith(
-      'docker',
-      ['compose', 'down', '-v'],
-      expect.any(Object)
-    )
-    expect(spawnSync).toHaveBeenCalledWith(
-      'npm',
-      ['run', 'db:reset:local'],
-      expect.any(Object)
-    )
-  })
-})

package/src/test/schema-diff.test.ts

@@ -1,232 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2024–2026 Flavio De Musso
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { mkdirSync, readdirSync, rmSync } from 'node:fs'
-import type { Seed } from '@beechcms/core'
-
-// ── fixtures ─────────────────────────────────────────────────────────────────
-
-const ARTICLE_SEED: Seed = {
-  slug: 'articles',
-  label: 'Articles',
-  displayNameAlias: 'title',
-  branches: [
-    { alias: 'title', label: 'Title', type: 'text' },
-    { alias: 'views', label: 'Views', type: 'number' },
-  ],
-} as Seed
-
-const REGISTRY: Record<string, Seed> = { articles: ARTICLE_SEED }
-
-// ── nextMigrationIndex ────────────────────────────────────────────────────────
-
-describe('nextMigrationIndex', () => {
-  let dir: string
-
-  beforeEach(() => {
-    dir = join(tmpdir(), `beech-test-${Date.now()}`)
-    mkdirSync(dir, { recursive: true })
-  })
-
-  afterEach(() => { rmSync(dir, { recursive: true, force: true }) })
-
-  it('returns 0000 when directory is empty', async () => {
-    const { nextMigrationIndex } = await import('../lib/migration-writer.js')
-    expect(nextMigrationIndex(dir)).toBe('0000')
-  })
-
-  it('returns 0034 when highest prefix is 0033', async () => {
-    const { nextMigrationIndex } = await import('../lib/migration-writer.js')
-    for (const name of ['0031_foo.sql', '0033_bar.sql', '0029_baz.sql']) {
-      const { writeFileSync } = await import('node:fs')
-      writeFileSync(join(dir, name), '')
-    }
-    expect(nextMigrationIndex(dir)).toBe('0034')
-  })
-
-  it('returns 0000 when directory does not exist', async () => {
-    const { nextMigrationIndex } = await import('../lib/migration-writer.js')
-    expect(nextMigrationIndex(join(tmpdir(), 'no-such-dir-beech'))).toBe('0000')
-  })
-})
-
-// ── buildMigrationSql ─────────────────────────────────────────────────────────
-
-describe('buildMigrationSql — additive emission', () => {
-  it('emits planCreateSeed statements when table is missing', async () => {
-    const { buildMigrationSql } = await import('../lib/migration-writer.js')
-    const diffs = [{ slug: 'articles', tableExists: false, columns: [] }]
-    const plan = buildMigrationSql(diffs, REGISTRY)
-    expect(plan.additiveCount).toBeGreaterThan(0)
-    expect(plan.sql).toContain('articles')
-    expect(plan.destructiveSlugs).toHaveLength(0)
-  })
-
-  it('emits generateAddColumn for missing columns', async () => {
-    const { buildMigrationSql } = await import('../lib/migration-writer.js')
-    const diffs = [{
-      slug: 'articles',
-      tableExists: true,
-      columns: [
-        { name: 'title', status: 'ok' as const },
-        { name: 'views', status: 'missing' as const, expectedType: 'REAL' },
-      ],
-    }]
-    const plan = buildMigrationSql(diffs, REGISTRY)
-    expect(plan.additiveCount).toBeGreaterThan(0)
-    expect(plan.sql).toContain('views')
-    expect(plan.destructiveSlugs).toHaveLength(0)
-  })
-
-  it('emits commented block for destructive drift, not executable SQL', async () => {
-    const { buildMigrationSql } = await import('../lib/migration-writer.js')
-    const diffs = [{
-      slug: 'articles',
-      tableExists: true,
-      columns: [
-        { name: 'title', status: 'type_mismatch' as const, expectedType: 'TEXT', actualType: 'INTEGER' },
-      ],
-    }]
-    const plan = buildMigrationSql(diffs, REGISTRY)
-    expect(plan.additiveCount).toBe(0)
-    expect(plan.destructiveSlugs).toContain('articles')
-    expect(plan.sql).toContain('-- ⚠')
-    expect(plan.sql).not.toMatch(/^ALTER TABLE/m)
-    expect(plan.sql).not.toMatch(/^DROP/m)
-  })
-
-  it('additiveCount is 0 when only destructive drift exists', async () => {
-    const { buildMigrationSql } = await import('../lib/migration-writer.js')
-    const diffs = [{
-      slug: 'articles',
-      tableExists: true,
-      columns: [
-        { name: 'title', status: 'extra' as const, actualType: 'TEXT' },
-      ],
-    }]
-    const plan = buildMigrationSql(diffs, REGISTRY)
-    expect(plan.additiveCount).toBe(0)
-    expect(plan.destructiveSlugs).toContain('articles')
-  })
-
-  it('processes seeds with no drift as no-op', async () => {
-    const { buildMigrationSql } = await import('../lib/migration-writer.js')
-    const diffs = [{
-      slug: 'articles',
-      tableExists: true,
-      columns: [
-        { name: 'title', status: 'ok' as const },
-        { name: 'views', status: 'ok' as const },
-      ],
-    }]
-    const plan = buildMigrationSql(diffs, REGISTRY)
-    expect(plan.additiveCount).toBe(0)
-    expect(plan.destructiveSlugs).toHaveLength(0)
-  })
-})
-
-// ── schemaDiff command ────────────────────────────────────────────────────────
-
-describe('schemaDiff command', () => {
-  beforeEach(() => { vi.resetModules() })
-
-  it('exits early when registry is empty', async () => {
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
-    const { schemaDiff } = await import('../commands/schema-diff.js')
-    await schemaDiff({ local: true, write: false, registry: {} })
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('No seeds found'))
-    consoleSpy.mockRestore()
-  })
-
-  it('prints preview SQL without writing files when no --write', async () => {
-    vi.doMock('../lib/wrangler.js', () => ({
-      findWranglerConfig: () => null,
-      resolveDbName: () => 'beech-db',
-      queryD1: () => [],
-    }))
-    vi.doMock('../lib/schema-diff.js', async () => {
-      const actual = await vi.importActual('../lib/schema-diff.js') as object
-      return {
-        ...actual,
-        diffSeed: vi.fn().mockResolvedValue({
-          slug: 'articles', tableExists: false, columns: [],
-        }),
-      }
-    })
-
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
-    const { schemaDiff } = await import('../commands/schema-diff.js')
-    await schemaDiff({ local: true, write: false, registry: REGISTRY })
-    const output = consoleSpy.mock.calls.flat().join('\n')
-    expect(output).toContain('Re-run with --write')
-    consoleSpy.mockRestore()
-    vi.doUnmock('../lib/wrangler.js')
-    vi.doUnmock('../lib/schema-diff.js')
-  })
-
-  it('writes migration file when --write and additive drift exists', async () => {
-    const dir = join(tmpdir(), `beech-schema-diff-test-${Date.now()}`)
-    mkdirSync(dir, { recursive: true })
-
-    vi.doMock('../lib/wrangler.js', () => ({
-      findWranglerConfig: () => null,
-      resolveDbName: () => 'beech-db',
-      queryD1: () => [],
-    }))
-    vi.doMock('../lib/schema-diff.js', async () => {
-      const actual = await vi.importActual('../lib/schema-diff.js') as object
-      return {
-        ...actual,
-        diffSeed: vi.fn().mockResolvedValue({
-          slug: 'articles', tableExists: false, columns: [],
-        }),
-      }
-    })
-
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
-    const { schemaDiff } = await import('../commands/schema-diff.js')
-    await schemaDiff({ local: true, write: true, name: 'test_migration', migrationsDir: dir, registry: REGISTRY })
-
-    const files = readdirSync(dir)
-    expect(files.some(f => f.endsWith('.sql'))).toBe(true)
-    const output = consoleSpy.mock.calls.flat().join('\n')
-    expect(output).toContain('Wrote')
-
-    consoleSpy.mockRestore()
-    rmSync(dir, { recursive: true, force: true })
-    vi.doUnmock('../lib/wrangler.js')
-    vi.doUnmock('../lib/schema-diff.js')
-  })
-
-  it('does not write file when only destructive drift', async () => {
-    vi.doMock('../lib/wrangler.js', () => ({
-      findWranglerConfig: () => null,
-      resolveDbName: () => 'beech-db',
-      queryD1: () => [],
-    }))
-    vi.doMock('../lib/schema-diff.js', async () => {
-      const actual = await vi.importActual('../lib/schema-diff.js') as object
-      return {
-        ...actual,
-        diffSeed: vi.fn().mockResolvedValue({
-          slug: 'articles',
-          tableExists: true,
-          columns: [{ name: 'title', status: 'type_mismatch', expectedType: 'TEXT', actualType: 'INTEGER' }],
-        }),
-      }
-    })
-
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
-    const { schemaDiff } = await import('../commands/schema-diff.js')
-    await schemaDiff({ local: true, write: true, registry: REGISTRY })
-    const output = consoleSpy.mock.calls.flat().join('\n')
-    expect(output).toContain('Only destructive drift')
-
-    consoleSpy.mockRestore()
-    vi.doUnmock('../lib/wrangler.js')
-    vi.doUnmock('../lib/schema-diff.js')
-  })
-})

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

@@ -1,158 +0,0 @@
-// 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'))
-  })
-})