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

package/.turbo/turbo-build.log

@@ -0,0 +1,5 @@
+$ tsc --noEmit && esbuild src/index.ts --bundle --packages=external --platform=node --format=esm --outfile=dist/index.js
+
+  dist/index.js  53.3kb
+
+⚡ Done in 5ms

package/dist/index.js

@@ -1248,10 +1248,147 @@ async function update(_args) {
   console.log(pc7.cyan("  3. npx beech seed:load"));
   console.log(pc7.dim("      \u2192 sync remote schema\n"));
 }
+
+// src/commands/reset.ts
+import pc8 from "picocolors";
+import { spawnSync as spawnSync5 } from "node:child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync5, rmSync as rmSync2 } from "node:fs";
+import { resolve as resolve4 } from "node:path";
+import { createInterface as createInterface3 } from "node:readline/promises";
+function isDockerInstalled() {
+  try {
+    const result = spawnSync5("docker", ["--version"], { stdio: "ignore", shell: true });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+function isDockerRunning() {
+  try {
+    const result = spawnSync5("docker", ["info"], { stdio: "ignore", shell: true });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+async function reset(args) {
+  console.log(pc8.cyan("\n  beech reset \u2014 cleanup environments\n"));
+  let resetDb = args.db || args.all;
+  let resetDocker = args.docker || args.all;
+  if (!args.db && !args.docker && !args.all) {
+    if (process.stdin.isTTY) {
+      const rl = createInterface3({ input: process.stdin, output: process.stdout });
+      try {
+        const answer = (await rl.question(
+          pc8.cyan("  \u2192 No options provided. Would you like to reset everything (DB & Docker)? (y/N): ")
+        )).trim().toLowerCase();
+        if (answer === "y" || answer === "yes") {
+          resetDb = true;
+          resetDocker = true;
+        } else {
+          console.log(pc8.dim("\n  Reset cancelled. Use --db, --docker, or --all.\n"));
+          return;
+        }
+      } finally {
+        rl.close();
+      }
+    } else {
+      console.log(pc8.red("\n  \u2717 Error: Please specify what to reset using --db, --docker, or --all.\n"));
+      process.exit(1);
+    }
+  }
+  const cwd = process.cwd();
+  if (resetDocker) {
+    if (!isDockerInstalled()) {
+      console.log(pc8.red("  \u2717 Docker is not installed or not found in your PATH."));
+      console.log(pc8.dim("    Please install Docker to reset Docker containers and volumes.\n"));
+      if (!args.all) {
+        process.exit(1);
+      }
+    } else if (!isDockerRunning()) {
+      console.log(pc8.yellow("  \u26A0 Docker is installed, but the Docker daemon is NOT running."));
+      console.log(pc8.dim("    Please start Docker Desktop or your Docker daemon to reset containers.\n"));
+      if (!args.all) {
+        process.exit(1);
+      }
+    } else {
+      console.log(pc8.dim("  Resetting Docker containers and volumes\u2026\n"));
+      const result = spawnSync5("docker", ["compose", "down", "-v"], {
+        stdio: "inherit",
+        cwd,
+        shell: true
+      });
+      if (result.status === 0) {
+        console.log(pc8.green("\n  \u2713 Docker containers stopped and volumes removed."));
+      } else {
+        console.log(pc8.red("\n  \u2717 Docker reset failed."));
+      }
+    }
+  }
+  if (resetDb) {
+    console.log(pc8.dim("\n  Resetting local database\u2026\n"));
+    let dbResetSuccess = false;
+    const apiDir = resolve4(cwd, "apps", "api");
+    if (existsSync4(resolve4(apiDir, "package.json"))) {
+      const result = spawnSync5("npm", ["run", "db:reset:local"], {
+        stdio: "inherit",
+        cwd: apiDir,
+        shell: true
+      });
+      dbResetSuccess = result.status === 0;
+    } else if (existsSync4(resolve4(cwd, "package.json"))) {
+      const pkg = JSON.parse(readFileSync5(resolve4(cwd, "package.json"), "utf-8"));
+      if (pkg.scripts?.["db:reset:local"]) {
+        const result = spawnSync5("npm", ["run", "db:reset:local"], {
+          stdio: "inherit",
+          cwd,
+          shell: true
+        });
+        dbResetSuccess = result.status === 0;
+      } else {
+        const wranglerStateDir = resolve4(cwd, ".wrangler/state");
+        if (existsSync4(wranglerStateDir)) {
+          console.log(pc8.dim("  Removing .wrangler/state\u2026"));
+          rmSync2(wranglerStateDir, { recursive: true, force: true });
+        }
+        if (existsSync4(resolve4(cwd, "scripts", "bootstrap-d1.mjs"))) {
+          const result = spawnSync5("node", ["scripts/bootstrap-d1.mjs"], {
+            stdio: "inherit",
+            cwd,
+            shell: true
+          });
+          dbResetSuccess = result.status === 0;
+        } else {
+          console.log(pc8.yellow("  \u26A0 Could not find database reset script."));
+          const initResult = spawnSync5("npx", ["beech", "init", "--db", "--local"], {
+            stdio: "inherit",
+            cwd,
+            shell: true
+          });
+          dbResetSuccess = initResult.status === 0;
+        }
+      }
+    } else {
+      const wranglerStateDir = resolve4(cwd, ".wrangler/state");
+      if (existsSync4(wranglerStateDir)) {
+        console.log(pc8.dim("  Removing .wrangler/state\u2026"));
+        rmSync2(wranglerStateDir, { recursive: true, force: true });
+      }
+      dbResetSuccess = true;
+    }
+    if (dbResetSuccess) {
+      console.log(pc8.green("\n  \u2713 Local database reset completed."));
+    } else {
+      console.log(pc8.red("\n  \u2717 Database reset failed."));
+    }
+  }
+  console.log(pc8.dim("\n  Reset process finished.\n"));
+}
 export {
   deploy,
   init,
   onboard,
+  reset,
   seedCreate,
   seedLoad,
   update,

package/package.json

@@ -1,25 +1,25 @@
 {
   "name": "@beechcms/cli",
-  "version": "0.6.0-preview.2",
+  "version": "0.6.0-preview.3",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
     ".": "./dist/index.js"
   },
-  "scripts": {
-    "build": "tsc --noEmit && esbuild src/index.ts --bundle --packages=external --platform=node --format=esm --outfile=dist/index.js",
-    "dev": "esbuild src/index.ts --bundle --packages=external --platform=node --format=esm --outfile=dist/index.js --watch",
-    "test": "vitest run",
-    "test:coverage": "vitest run --coverage"
-  },
   "dependencies": {
-    "@beechcms/core": "^0.6.0-preview.2",
+    "@beechcms/core": "^0.6.0-preview.3",
     "picocolors": "^1.1.1"
   },
   "devDependencies": {
-    "esbuild": "^0.27.3",
+    "esbuild": "^0.28.1",
     "typescript": "^5.9.3",
     "vitest": "^4.1.0"
   },
-  "license": "MIT"
-}
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc --noEmit && esbuild src/index.ts --bundle --packages=external --platform=node --format=esm --outfile=dist/index.js",
+    "dev": "esbuild src/index.ts --bundle --packages=external --platform=node --format=esm --outfile=dist/index.js --watch",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  }
+}

package/src/commands/reset.ts

@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+
+import pc from 'picocolors'
+import { spawnSync } from 'node:child_process'
+import { existsSync, readFileSync, rmSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { createInterface } from 'node:readline/promises'
+
+export interface ResetOptions {
+  db?: boolean
+  docker?: boolean
+  all?: boolean
+}
+
+function isDockerInstalled(): boolean {
+  try {
+    const result = spawnSync('docker', ['--version'], { stdio: 'ignore', shell: true })
+    return result.status === 0
+  } catch {
+    return false
+  }
+}
+
+function isDockerRunning(): boolean {
+  try {
+    const result = spawnSync('docker', ['info'], { stdio: 'ignore', shell: true })
+    return result.status === 0
+  } catch {
+    return false
+  }
+}
+
+export async function reset(args: ResetOptions): Promise<void> {
+  console.log(pc.cyan('\n  beech reset — cleanup environments\n'))
+
+  let resetDb = args.db || args.all
+  let resetDocker = args.docker || args.all
+
+  if (!args.db && !args.docker && !args.all) {
+    if (process.stdin.isTTY) {
+      const rl = createInterface({ input: process.stdin, output: process.stdout })
+      try {
+        const answer = (await rl.question(
+          pc.cyan('  → No options provided. Would you like to reset everything (DB & Docker)? (y/N): ')
+        )).trim().toLowerCase()
+        if (answer === 'y' || answer === 'yes') {
+          resetDb = true
+          resetDocker = true
+        } else {
+          console.log(pc.dim('\n  Reset cancelled. Use --db, --docker, or --all.\n'))
+          return
+        }
+      } finally {
+        rl.close()
+      }
+    } else {
+      console.log(pc.red('\n  ✗ Error: Please specify what to reset using --db, --docker, or --all.\n'))
+      process.exit(1)
+    }
+  }
+
+  const cwd = process.cwd()
+
+  // Reset Docker
+  if (resetDocker) {
+    if (!isDockerInstalled()) {
+      console.log(pc.red('  ✗ Docker is not installed or not found in your PATH.'))
+      console.log(pc.dim('    Please install Docker to reset Docker containers and volumes.\n'))
+      if (!args.all) {
+        process.exit(1)
+      }
+    } else if (!isDockerRunning()) {
+      console.log(pc.yellow('  ⚠ Docker is installed, but the Docker daemon is NOT running.'))
+      console.log(pc.dim('    Please start Docker Desktop or your Docker daemon to reset containers.\n'))
+      if (!args.all) {
+        process.exit(1)
+      }
+    } else {
+      console.log(pc.dim('  Resetting Docker containers and volumes…\n'))
+      const result = spawnSync('docker', ['compose', 'down', '-v'], {
+        stdio: 'inherit',
+        cwd,
+        shell: true,
+      })
+
+      if (result.status === 0) {
+        console.log(pc.green('\n  ✓ Docker containers stopped and volumes removed.'))
+      } else {
+        console.log(pc.red('\n  ✗ Docker reset failed.'))
+      }
+    }
+  }
+
+  // Reset DB
+  if (resetDb) {
+    console.log(pc.dim('\n  Resetting local database…\n'))
+    let dbResetSuccess = false
+    const apiDir = resolve(cwd, 'apps', 'api')
+
+    if (existsSync(resolve(apiDir, 'package.json'))) {
+      const result = spawnSync('npm', ['run', 'db:reset:local'], {
+        stdio: 'inherit',
+        cwd: apiDir,
+        shell: true,
+      })
+      dbResetSuccess = result.status === 0
+    } else if (existsSync(resolve(cwd, 'package.json'))) {
+      const pkg = JSON.parse(readFileSync(resolve(cwd, 'package.json'), 'utf-8'))
+      if (pkg.scripts?.['db:reset:local']) {
+        const result = spawnSync('npm', ['run', 'db:reset:local'], {
+          stdio: 'inherit',
+          cwd,
+          shell: true,
+        })
+        dbResetSuccess = result.status === 0
+      } else {
+        const wranglerStateDir = resolve(cwd, '.wrangler/state')
+        if (existsSync(wranglerStateDir)) {
+          console.log(pc.dim('  Removing .wrangler/state…'))
+          rmSync(wranglerStateDir, { recursive: true, force: true })
+        }
+        if (existsSync(resolve(cwd, 'scripts', 'bootstrap-d1.mjs'))) {
+          const result = spawnSync('node', ['scripts/bootstrap-d1.mjs'], {
+            stdio: 'inherit',
+            cwd,
+            shell: true,
+          })
+          dbResetSuccess = result.status === 0
+        } else {
+          console.log(pc.yellow('  ⚠ Could not find database reset script.'))
+          const initResult = spawnSync('npx', ['beech', 'init', '--db', '--local'], {
+            stdio: 'inherit',
+            cwd,
+            shell: true,
+          })
+          dbResetSuccess = initResult.status === 0
+        }
+      }
+    } else {
+      const wranglerStateDir = resolve(cwd, '.wrangler/state')
+      if (existsSync(wranglerStateDir)) {
+        console.log(pc.dim('  Removing .wrangler/state…'))
+        rmSync(wranglerStateDir, { recursive: true, force: true })
+      }
+      dbResetSuccess = true
+    }
+
+    if (dbResetSuccess) {
+      console.log(pc.green('\n  ✓ Local database reset completed.'))
+    } else {
+      console.log(pc.red('\n  ✗ Database reset failed.'))
+    }
+  }
+
+  console.log(pc.dim('\n  Reset process finished.\n'))
+}

package/src/index.ts

@@ -15,3 +15,6 @@ export { onboard } from './commands/onboard.js'
 export type { OnboardOptions } from './commands/onboard.js'
 export { update } from './commands/update.js'
 export type { UpdateOptions } from './commands/update.js'
+export { reset } from './commands/reset.js'
+export type { ResetOptions } from './commands/reset.js'
+

package/src/test/reset.test.ts

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