@sqldoc/sqldoc 0.0.1

package/package.json

@@ -0,0 +1,37 @@
+{
+  "type": "module",
+  "name": "@sqldoc/sqldoc",
+  "version": "0.0.1",
+  "description": "Global CLI shim for sqldoc -- finds .sqldoc/ and delegates to project-local @sqldoc/cli",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./src/index.ts",
+      "default": "./src/index.ts"
+    }
+  },
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "bin": {
+    "sqldoc": "./src/index.ts"
+  },
+  "files": [
+    "src",
+    "package.json"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.0"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/__tests__/detect-pm.test.ts

@@ -0,0 +1,67 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+import { detectPM } from '../detect-pm.ts'
+
+describe('detectPM', () => {
+  const tempDirs: string[] = []
+
+  function makeTempDir(): string {
+    const dir = mkdtempSync(join(tmpdir(), 'sqldoc-pm-test-'))
+    tempDirs.push(dir)
+    return dir
+  }
+
+  afterEach(() => {
+    for (const dir of tempDirs) {
+      rmSync(dir, { recursive: true, force: true })
+    }
+    tempDirs.length = 0
+  })
+
+  it("returns 'pnpm' when pnpm-lock.yaml exists", () => {
+    const root = makeTempDir()
+    writeFileSync(join(root, 'pnpm-lock.yaml'), '')
+    expect(detectPM(root)).toBe('pnpm')
+  })
+
+  it("returns 'yarn' when yarn.lock exists", () => {
+    const root = makeTempDir()
+    writeFileSync(join(root, 'yarn.lock'), '')
+    expect(detectPM(root)).toBe('yarn')
+  })
+
+  it("returns 'bun' when bun.lockb exists", () => {
+    const root = makeTempDir()
+    writeFileSync(join(root, 'bun.lockb'), '')
+    expect(detectPM(root)).toBe('bun')
+  })
+
+  it("returns 'bun' when bun.lock exists", () => {
+    const root = makeTempDir()
+    writeFileSync(join(root, 'bun.lock'), '')
+    expect(detectPM(root)).toBe('bun')
+  })
+
+  it("returns 'npm' when package-lock.json exists", () => {
+    const root = makeTempDir()
+    writeFileSync(join(root, 'package-lock.json'), '')
+    expect(detectPM(root)).toBe('npm')
+  })
+
+  it("returns 'npm' as fallback when no lockfile found", () => {
+    const root = makeTempDir()
+    expect(detectPM(root)).toBe('npm')
+  })
+
+  it('checks in priority order: pnpm > yarn > bun > npm', () => {
+    const root = makeTempDir()
+    // When all lockfiles exist, pnpm should win
+    writeFileSync(join(root, 'pnpm-lock.yaml'), '')
+    writeFileSync(join(root, 'yarn.lock'), '')
+    writeFileSync(join(root, 'bun.lockb'), '')
+    writeFileSync(join(root, 'package-lock.json'), '')
+    expect(detectPM(root)).toBe('pnpm')
+  })
+})

package/src/__tests__/find-sqldoc.test.ts

@@ -0,0 +1,60 @@
+import { mkdirSync, mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+import { findSqldocDir } from '../find-sqldoc.ts'
+
+describe('findSqldocDir', () => {
+  const tempDirs: string[] = []
+
+  function makeTempDir(): string {
+    const dir = mkdtempSync(join(tmpdir(), 'sqldoc-test-'))
+    tempDirs.push(dir)
+    return dir
+  }
+
+  afterEach(() => {
+    for (const dir of tempDirs) {
+      rmSync(dir, { recursive: true, force: true })
+    }
+    tempDirs.length = 0
+  })
+
+  it('returns absolute path when .sqldoc/ exists in startDir', () => {
+    const root = makeTempDir()
+    const sqldocDir = join(root, '.sqldoc')
+    mkdirSync(sqldocDir)
+
+    const result = findSqldocDir(root)
+    expect(result).toBe(sqldocDir)
+  })
+
+  it('returns absolute path when .sqldoc/ exists in a parent directory', () => {
+    const root = makeTempDir()
+    const sqldocDir = join(root, '.sqldoc')
+    mkdirSync(sqldocDir)
+
+    const nested = join(root, 'a', 'b', 'c')
+    mkdirSync(nested, { recursive: true })
+
+    const result = findSqldocDir(nested)
+    expect(result).toBe(sqldocDir)
+  })
+
+  it('returns null when .sqldoc/ does not exist up to filesystem root', () => {
+    const root = makeTempDir()
+    const nested = join(root, 'no-sqldoc', 'deep')
+    mkdirSync(nested, { recursive: true })
+
+    // Start from a deep dir with no .sqldoc anywhere above
+    // Use the temp dir itself (no .sqldoc) -- will walk up to / and find nothing
+    const result = findSqldocDir(nested)
+    expect(result).toBeNull()
+  })
+
+  it('uses process.cwd() as default startDir', () => {
+    // Just verify it doesn't throw when called without args
+    const result = findSqldocDir()
+    expect(result === null || typeof result === 'string').toBe(true)
+  })
+})

package/src/__tests__/generate-config-types.test.ts

@@ -0,0 +1,121 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+import { generateConfigTypes } from '../generate-config-types.ts'
+
+describe('generateConfigTypes', () => {
+  const tempDirs: string[] = []
+
+  function makeTempDir(): string {
+    const dir = mkdtempSync(join(tmpdir(), 'sqldoc-config-types-test-'))
+    tempDirs.push(dir)
+    return dir
+  }
+
+  afterEach(() => {
+    for (const dir of tempDirs) {
+      rmSync(dir, { recursive: true, force: true })
+    }
+    tempDirs.length = 0
+  })
+
+  it('does nothing when node_modules/@sqldoc does not exist', () => {
+    const sqldocDir = makeTempDir()
+    generateConfigTypes(sqldocDir)
+    expect(existsSync(join(sqldocDir, 'config.d.ts'))).toBe(false)
+  })
+
+  it('generates config.d.ts with base fields when no ns-* packages', () => {
+    const sqldocDir = makeTempDir()
+    mkdirSync(join(sqldocDir, 'node_modules', '@sqldoc'), { recursive: true })
+
+    generateConfigTypes(sqldocDir)
+
+    const content = readFileSync(join(sqldocDir, 'config.d.ts'), 'utf-8')
+    expect(content).toContain('Auto-generated by sqldoc')
+    expect(content).toContain('interface ProjectConfig extends BaseProjectConfig')
+    expect(content).toContain('export type SqldocConfig = ProjectConfig | ProjectConfig[]')
+  })
+
+  it('detects ns-* packages and adds namespace fields', () => {
+    const sqldocDir = makeTempDir()
+    const nsDir = join(sqldocDir, 'node_modules', '@sqldoc', 'ns-audit')
+    mkdirSync(nsDir, { recursive: true })
+    writeFileSync(join(nsDir, 'package.json'), JSON.stringify({ name: '@sqldoc/ns-audit' }))
+
+    generateConfigTypes(sqldocDir)
+
+    const content = readFileSync(join(sqldocDir, 'config.d.ts'), 'utf-8')
+    expect(content).toContain('namespaces?:')
+    expect(content).toContain('audit?: Record<string, unknown>')
+  })
+
+  it('picks up exported Config types from namespace source', () => {
+    const sqldocDir = makeTempDir()
+    const nsDir = join(sqldocDir, 'node_modules', '@sqldoc', 'ns-docs')
+    const srcDir = join(nsDir, 'src')
+    mkdirSync(srcDir, { recursive: true })
+    writeFileSync(join(nsDir, 'package.json'), JSON.stringify({ name: '@sqldoc/ns-docs' }))
+    writeFileSync(
+      join(srcDir, 'index.ts'),
+      `
+export default plugin
+export type { DocsConfig }
+`,
+    )
+
+    generateConfigTypes(sqldocDir)
+
+    const content = readFileSync(join(sqldocDir, 'config.d.ts'), 'utf-8')
+    expect(content).toContain("import type { DocsConfig } from '@sqldoc/ns-docs'")
+    expect(content).toContain('docs?: Partial<DocsConfig>')
+  })
+
+  it('handles multiple namespace packages sorted alphabetically', () => {
+    const sqldocDir = makeTempDir()
+    const sqldocNm = join(sqldocDir, 'node_modules', '@sqldoc')
+
+    // Create ns-validate (no config type)
+    const validateDir = join(sqldocNm, 'ns-validate')
+    mkdirSync(validateDir, { recursive: true })
+    writeFileSync(join(validateDir, 'package.json'), JSON.stringify({ name: '@sqldoc/ns-validate' }))
+
+    // Create ns-codegen (with config type)
+    const codegenDir = join(sqldocNm, 'ns-codegen')
+    const codegenSrc = join(codegenDir, 'src')
+    mkdirSync(codegenSrc, { recursive: true })
+    writeFileSync(join(codegenDir, 'package.json'), JSON.stringify({ name: '@sqldoc/ns-codegen' }))
+    writeFileSync(join(codegenSrc, 'index.ts'), `export type { CodegenConfig } from './types'`)
+
+    generateConfigTypes(sqldocDir)
+
+    const content = readFileSync(join(sqldocDir, 'config.d.ts'), 'utf-8')
+    // codegen comes before validate alphabetically
+    expect(content).toContain("import type { CodegenConfig } from '@sqldoc/ns-codegen'")
+    expect(content).toContain('codegen?: Partial<CodegenConfig>')
+    expect(content).toContain('validate?: Record<string, unknown>')
+
+    // codegen should appear before validate in the file
+    const codegenIdx = content.indexOf('codegen?:')
+    const validateIdx = content.indexOf('validate?:')
+    expect(codegenIdx).toBeLessThan(validateIdx)
+  })
+
+  it('skips non-ns packages like cli and templates', () => {
+    const sqldocDir = makeTempDir()
+    const sqldocNm = join(sqldocDir, 'node_modules', '@sqldoc')
+
+    mkdirSync(join(sqldocNm, 'cli'), { recursive: true })
+    writeFileSync(join(sqldocNm, 'cli', 'package.json'), JSON.stringify({ name: '@sqldoc/cli' }))
+
+    mkdirSync(join(sqldocNm, 'templates'), { recursive: true })
+    writeFileSync(join(sqldocNm, 'templates', 'package.json'), JSON.stringify({ name: '@sqldoc/templates' }))
+
+    generateConfigTypes(sqldocDir)
+
+    const content = readFileSync(join(sqldocDir, 'config.d.ts'), 'utf-8')
+    expect(content).not.toContain('cli')
+    expect(content).not.toContain('templates')
+  })
+})

package/src/__tests__/init.test.ts

@@ -0,0 +1,117 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+describe('initCommand', () => {
+  const tempDirs: string[] = []
+  let exitSpy: ReturnType<typeof vi.spyOn>
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>
+
+  function makeTempDir(): string {
+    const dir = mkdtempSync(join(tmpdir(), 'sqldoc-init-test-'))
+    tempDirs.push(dir)
+    return dir
+  }
+
+  /** Create a minimal fake repo so devPath mode has something to link */
+  function makeFakeRepo(): string {
+    const repo = makeTempDir()
+    const pkgDir = join(repo, 'packages', 'cli')
+    mkdirSync(pkgDir, { recursive: true })
+    writeFileSync(join(pkgDir, 'package.json'), JSON.stringify({ name: '@sqldoc/cli' }))
+    return repo
+  }
+
+  beforeEach(() => {
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as any)
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    for (const dir of tempDirs) {
+      rmSync(dir, { recursive: true, force: true })
+    }
+    tempDirs.length = 0
+    exitSpy.mockRestore()
+    consoleLogSpy.mockRestore()
+    consoleErrorSpy.mockRestore()
+  })
+
+  it('creates .sqldoc/ directory', async () => {
+    const root = makeTempDir()
+    const repo = makeFakeRepo()
+    const { initCommand } = await import('../commands/init.ts')
+    await initCommand(root, repo)
+
+    expect(existsSync(join(root, '.sqldoc'))).toBe(true)
+  })
+
+  it('creates .sqldoc/package.json with correct structure', async () => {
+    const root = makeTempDir()
+    const repo = makeFakeRepo()
+    const { initCommand } = await import('../commands/init.ts')
+    await initCommand(root, repo)
+
+    const pkgPath = join(root, '.sqldoc', 'package.json')
+    expect(existsSync(pkgPath)).toBe(true)
+
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'))
+    expect(pkg.name).toBe('sqldoc-local')
+    expect(pkg.private).toBe(true)
+  })
+
+  it('creates .sqldoc/.gitignore containing node_modules/', async () => {
+    const root = makeTempDir()
+    const repo = makeFakeRepo()
+    const { initCommand } = await import('../commands/init.ts')
+    await initCommand(root, repo)
+
+    const gitignorePath = join(root, '.sqldoc', '.gitignore')
+    expect(existsSync(gitignorePath)).toBe(true)
+
+    const content = readFileSync(gitignorePath, 'utf-8')
+    expect(content).toContain('node_modules/')
+  })
+
+  it('errors when .sqldoc/ already exists', async () => {
+    const root = makeTempDir()
+    mkdirSync(join(root, '.sqldoc'))
+
+    const { initCommand } = await import('../commands/init.ts')
+    await initCommand(root)
+
+    expect(exitSpy).toHaveBeenCalledWith(1)
+    const errorOutput = consoleErrorSpy.mock.calls.map((c: any[]) => String(c[0])).join(' ')
+    expect(errorOutput).toContain('already exists')
+  })
+
+  it('creates sqldoc.config.ts when none exists', async () => {
+    const root = makeTempDir()
+    const repo = makeFakeRepo()
+    const { initCommand } = await import('../commands/init.ts')
+    await initCommand(root, repo)
+
+    const configPath = join(root, 'sqldoc.config.ts')
+    expect(existsSync(configPath)).toBe(true)
+
+    const content = readFileSync(configPath, 'utf-8')
+    expect(content).toContain('export default')
+  })
+
+  it('does not overwrite existing sqldoc.config.ts', async () => {
+    const root = makeTempDir()
+    const repo = makeFakeRepo()
+    const configPath = join(root, 'sqldoc.config.ts')
+    const originalContent = 'export default { custom: true }\n'
+    writeFileSync(configPath, originalContent)
+
+    const { initCommand } = await import('../commands/init.ts')
+    await initCommand(root, repo)
+
+    const content = readFileSync(configPath, 'utf-8')
+    expect(content).toBe(originalContent)
+  })
+})

package/src/__tests__/prompt.test.ts

@@ -0,0 +1,164 @@
+import * as readline from 'node:readline'
+import { Readable, Writable } from 'node:stream'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { promptCheckbox, promptConfirm, promptSelect } from '../prompt.ts'
+
+/**
+ * Create a readline interface backed by a mock input stream.
+ * Call `type(answer)` to feed the answer before the prompt reads it.
+ */
+function mockRL() {
+  const input = new Readable({ read() {} })
+  const output = new Writable({
+    write(_chunk, _enc, cb) {
+      cb()
+    },
+  })
+  const rl = readline.createInterface({ input, output })
+
+  return {
+    rl,
+    type(answer: string) {
+      // Push the answer followed by newline into the readable stream
+      input.push(`${answer}\n`)
+    },
+    close() {
+      rl.close()
+      input.destroy()
+    },
+  }
+}
+
+describe('promptSelect', () => {
+  let consoleSpy: ReturnType<typeof vi.spyOn>
+
+  beforeEach(() => {
+    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    consoleSpy.mockRestore()
+  })
+
+  it('returns default when user presses Enter', async () => {
+    const { rl, type, close } = mockRL()
+    const p = promptSelect(
+      rl,
+      'Pick:',
+      [
+        { value: 'a', label: 'Option A' },
+        { value: 'b', label: 'Option B' },
+      ],
+      'b',
+    )
+    type('')
+    const result = await p
+    expect(result).toBe('b')
+    close()
+  })
+
+  it('returns selected option by number', async () => {
+    const { rl, type, close } = mockRL()
+    const p = promptSelect(
+      rl,
+      'Pick:',
+      [
+        { value: 'a', label: 'Option A' },
+        { value: 'b', label: 'Option B' },
+      ],
+      'a',
+    )
+    type('2')
+    const result = await p
+    expect(result).toBe('b')
+    close()
+  })
+
+  it('returns default for invalid input', async () => {
+    const { rl, type, close } = mockRL()
+    const p = promptSelect(rl, 'Pick:', [{ value: 'a', label: 'Option A' }], 'a')
+    type('99')
+    const result = await p
+    expect(result).toBe('a')
+    close()
+  })
+})
+
+describe('promptCheckbox', () => {
+  let consoleSpy: ReturnType<typeof vi.spyOn>
+
+  beforeEach(() => {
+    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    consoleSpy.mockRestore()
+  })
+
+  it('returns defaults when user presses Enter', async () => {
+    const { rl, type, close } = mockRL()
+    const p = promptCheckbox(rl, 'Pick:', [
+      { value: 'a', label: 'A', checked: true },
+      { value: 'b', label: 'B', checked: false },
+      { value: 'c', label: 'C', checked: true },
+    ])
+    type('')
+    const result = await p
+    expect(result).toEqual(['a', 'c'])
+    close()
+  })
+
+  it('returns selected items by number', async () => {
+    const { rl, type, close } = mockRL()
+    const p = promptCheckbox(rl, 'Pick:', [
+      { value: 'a', label: 'A' },
+      { value: 'b', label: 'B' },
+      { value: 'c', label: 'C' },
+    ])
+    type('1,3')
+    const result = await p
+    expect(result).toEqual(['a', 'c'])
+    close()
+  })
+
+  it('handles spaces in comma-separated input', async () => {
+    const { rl, type, close } = mockRL()
+    const p = promptCheckbox(rl, 'Pick:', [
+      { value: 'a', label: 'A' },
+      { value: 'b', label: 'B' },
+    ])
+    type('1, 2')
+    const result = await p
+    expect(result).toEqual(['a', 'b'])
+    close()
+  })
+})
+
+describe('promptConfirm', () => {
+  it('returns true on empty input (Enter)', async () => {
+    const { rl, type, close } = mockRL()
+    const p = promptConfirm(rl, 'Continue?')
+    type('')
+    const result = await p
+    expect(result).toBe(true)
+    close()
+  })
+
+  it('returns true on "y"', async () => {
+    const { rl, type, close } = mockRL()
+    const p = promptConfirm(rl, 'Continue?')
+    type('y')
+    const result = await p
+    expect(result).toBe(true)
+    close()
+  })
+
+  it('returns false on "n"', async () => {
+    const { rl, type, close } = mockRL()
+    const p = promptConfirm(rl, 'Continue?')
+    type('n')
+    const result = await p
+    expect(result).toBe(false)
+    close()
+  })
+})

package/src/__tests__/scaffold.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, it } from 'vitest'
+import { namespacesToInstall, scaffoldConfig, scaffoldExample } from '../scaffold.ts'
+
+describe('scaffoldConfig', () => {
+  it('generates minimal config with default postgres dialect', () => {
+    const result = scaffoldConfig({ dialect: 'postgres', namespaces: [], templates: [] })
+    expect(result).toContain("import type { SqldocConfig } from './.sqldoc/config'")
+    expect(result).toContain('const config: SqldocConfig')
+    expect(result).toContain('export default config')
+    // Dialect is always emitted (mandatory field)
+    expect(result).toContain("dialect: 'postgres'")
+    // Should have devUrl hint
+    expect(result).toContain('// devUrl:')
+  })
+
+  it('sets dialect for non-default', () => {
+    const result = scaffoldConfig({ dialect: 'mysql', namespaces: [], templates: [] })
+    expect(result).toContain("dialect: 'mysql'")
+    expect(result).toContain('mysql://localhost')
+  })
+
+  it('includes namespace config sections', () => {
+    const result = scaffoldConfig({ dialect: 'postgres', namespaces: ['audit', 'validate'], templates: [] })
+    expect(result).toContain('namespaces: {')
+    expect(result).toContain('audit: {}')
+    expect(result).toContain('validate: {}')
+  })
+
+  it('includes docs config with defaults', () => {
+    const result = scaffoldConfig({ dialect: 'postgres', namespaces: ['docs'], templates: [] })
+    expect(result).toContain("format: 'html'")
+    expect(result).toContain("output: 'docs/schema.html'")
+  })
+
+  it('includes codegen config with templates', () => {
+    const result = scaffoldConfig({ dialect: 'postgres', namespaces: ['codegen'], templates: ['typescript', 'zod'] })
+    expect(result).toContain('templates: [')
+    expect(result).toContain("'@sqldoc/templates/typescript'")
+    expect(result).toContain("'@sqldoc/templates/zod'")
+    expect(result).toContain("'generated/types.ts'")
+    expect(result).toContain("'generated/schemas.ts'")
+  })
+
+  it('generates sqlite config', () => {
+    const result = scaffoldConfig({ dialect: 'sqlite', namespaces: [], templates: [] })
+    expect(result).toContain("dialect: 'sqlite'")
+    expect(result).toContain('sqlite://dev.db')
+  })
+})
+
+describe('scaffoldExample', () => {
+  it('generates imports for selected namespaces', () => {
+    const result = scaffoldExample({ dialect: 'postgres', namespaces: ['audit', 'validate'], templates: [] })
+    expect(result).toContain('-- @import @sqldoc/ns-audit')
+    expect(result).toContain('-- @import @sqldoc/ns-validate')
+  })
+
+  it('includes table-level tags', () => {
+    const result = scaffoldExample({ dialect: 'postgres', namespaces: ['audit', 'rls'], templates: [] })
+    expect(result).toContain('-- @audit')
+    expect(result).toContain('-- @rls')
+    expect(result).toContain('CREATE TABLE users')
+  })
+
+  it('includes column-level tags', () => {
+    const result = scaffoldExample({ dialect: 'postgres', namespaces: ['validate'], templates: [] })
+    expect(result).toContain('@validate.check')
+  })
+
+  it('includes anon tags', () => {
+    const result = scaffoldExample({ dialect: 'postgres', namespaces: ['anon'], templates: [] })
+    expect(result).toContain('@anon.mask')
+  })
+
+  it('adapts to mysql dialect', () => {
+    const result = scaffoldExample({ dialect: 'mysql', namespaces: ['validate'], templates: [] })
+    expect(result).toContain('INT AUTO_INCREMENT')
+    expect(result).toContain('VARCHAR(255)')
+  })
+
+  it('adapts to sqlite dialect', () => {
+    const result = scaffoldExample({ dialect: 'sqlite', namespaces: ['validate'], templates: [] })
+    expect(result).toContain('INTEGER')
+    expect(result).toContain('TEXT DEFAULT CURRENT_TIMESTAMP')
+  })
+
+  it('generates rls policy example for postgres', () => {
+    const result = scaffoldExample({ dialect: 'postgres', namespaces: ['rls'], templates: [] })
+    expect(result).toContain('@rls.policy')
+  })
+})
+
+describe('namespacesToInstall', () => {
+  it('always includes @sqldoc/cli', () => {
+    expect(namespacesToInstall([], [])).toContain('@sqldoc/cli')
+  })
+
+  it('maps namespace names to packages', () => {
+    const result = namespacesToInstall(['audit', 'validate'], [])
+    expect(result).toContain('@sqldoc/ns-audit')
+    expect(result).toContain('@sqldoc/ns-validate')
+  })
+
+  it('includes templates package when codegen has templates', () => {
+    const result = namespacesToInstall(['codegen'], ['typescript'])
+    expect(result).toContain('@sqldoc/ns-codegen')
+    expect(result).toContain('@sqldoc/templates')
+  })
+
+  it('does not include templates when codegen has no templates', () => {
+    const result = namespacesToInstall(['codegen'], [])
+    expect(result).toContain('@sqldoc/ns-codegen')
+    expect(result).not.toContain('@sqldoc/templates')
+  })
+})