@actuate-media/cli 0.4.1 → 0.5.0

package/src/commands/db-status.ts

@@ -1,120 +1,122 @@
-import { Command } from "commander";
-import { execSync } from "node:child_process";
-import { readFile, access } from "node:fs/promises";
-import { resolve } from "node:path";
-import ora from "ora";
-import chalk from "chalk";
-import { logger } from "../utils/logger.js";
-import { REQUIRED_CMS_MODELS } from "../deployment/diagnostics.js";
+import { Command } from 'commander'
+import { execSync } from 'node:child_process'
+import { readFile, access } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import ora from 'ora'
+import chalk from 'chalk'
+import { logger } from '../utils/logger.js'
+import { REQUIRED_CMS_MODELS } from '../deployment/diagnostics.js'
 
-const CMS_SCHEMA_MARKER = "// ── Actuate CMS models";
+const CMS_SCHEMA_MARKER = '// ── Actuate CMS models'
 
 async function fileExists(filePath: string): Promise<boolean> {
   try {
-    await access(filePath);
-    return true;
+    await access(filePath)
+    return true
   } catch {
-    return false;
+    return false
   }
 }
 
 export function registerDbStatusCommand(program: Command): void {
   program
-    .command("db:status")
-    .description("Check which Actuate CMS models are present in your Prisma schema")
-    .option("--schema <path>", "Path to schema.prisma", "prisma/schema.prisma")
+    .command('db:status')
+    .description('Check which Actuate CMS models are present in your Prisma schema')
+    .option('--schema <path>', 'Path to schema.prisma', 'prisma/schema.prisma')
     .action(async (opts: { schema: string }) => {
-      const schemaPath = resolve(process.cwd(), opts.schema);
+      const schemaPath = resolve(process.cwd(), opts.schema)
 
       if (!(await fileExists(schemaPath))) {
-        logger.error(`Schema file not found at ${schemaPath}`);
-        logger.info("Run `npx prisma init` first, or specify --schema <path>.");
-        process.exitCode = 1;
-        return;
+        logger.error(`Schema file not found at ${schemaPath}`)
+        logger.info('Run `npx prisma init` first, or specify --schema <path>.')
+        process.exitCode = 1
+        return
       }
 
-      const spinner = ora("Checking schema...").start();
+      const spinner = ora('Checking schema...').start()
 
-      let content: string;
+      let content: string
       try {
-        content = await readFile(schemaPath, "utf-8");
+        content = await readFile(schemaPath, 'utf-8')
       } catch (err) {
-        spinner.fail("Failed to read schema file.");
-        logger.error(err instanceof Error ? err.message : String(err));
-        process.exitCode = 1;
-        return;
+        spinner.fail('Failed to read schema file.')
+        logger.error(err instanceof Error ? err.message : String(err))
+        process.exitCode = 1
+        return
       }
 
-      spinner.stop();
+      spinner.stop()
 
-      const hasMarker = content.includes(CMS_SCHEMA_MARKER);
-      const modelRegex = /^model\s+(\w+)\s*\{/gm;
-      const schemaModels = new Set<string>();
-      let match;
+      const hasMarker = content.includes(CMS_SCHEMA_MARKER)
+      const modelRegex = /^model\s+(\w+)\s*\{/gm
+      const schemaModels = new Set<string>()
+      let match
       while ((match = modelRegex.exec(content)) !== null) {
-        schemaModels.add(match[1]!);
+        schemaModels.add(match[1]!)
       }
 
-      console.log();
-      console.log(chalk.bold("  Actuate CMS Model Status"));
-      console.log(chalk.dim("  ─────────────────────────────────"));
-      console.log();
+      console.log()
+      console.log(chalk.bold('  Actuate CMS Model Status'))
+      console.log(chalk.dim('  ─────────────────────────────────'))
+      console.log()
 
-      let present = 0;
-      let missing = 0;
+      let present = 0
+      let missing = 0
 
       for (const model of REQUIRED_CMS_MODELS) {
         if (schemaModels.has(model)) {
-          console.log(`  ${chalk.green("✓")} ${model}`);
-          present++;
+          console.log(`  ${chalk.green('✓')} ${model}`)
+          present++
         } else {
-          console.log(`  ${chalk.red("✗")} ${model} ${chalk.dim("— missing")}`);
-          missing++;
+          console.log(`  ${chalk.red('✗')} ${model} ${chalk.dim('— missing')}`)
+          missing++
         }
       }
 
-      console.log();
-      console.log(chalk.dim("  ─────────────────────────────────"));
-      console.log(`  ${chalk.green(present)} present, ${missing > 0 ? chalk.red(missing) : chalk.green(missing)} missing`);
+      console.log()
+      console.log(chalk.dim('  ─────────────────────────────────'))
+      console.log(
+        `  ${chalk.green(present)} present, ${missing > 0 ? chalk.red(missing) : chalk.green(missing)} missing`,
+      )
 
       if (!hasMarker) {
-        console.log();
-        logger.warn("CMS schema marker not found. Models may have been added manually.");
-        logger.info("Run `actuate db:init` to add CMS models with proper markers.");
+        console.log()
+        logger.warn('CMS schema marker not found. Models may have been added manually.')
+        logger.info('Run `actuate db:init` to add CMS models with proper markers.')
       }
 
       if (missing > 0) {
-        console.log();
-        logger.info("Run `actuate db:init` to add missing models.");
+        console.log()
+        logger.info('Run `actuate db:init` to add missing models.')
       }
 
-      let dbConnected = false;
+      let dbConnected = false
       try {
-        spinner.start("Checking database connection...");
-        execSync("npx prisma db execute --stdin --schema " + JSON.stringify(schemaPath), {
-          input: "SELECT 1;",
-          stdio: ["pipe", "pipe", "pipe"],
+        spinner.start('Checking database connection...')
+        execSync('npx prisma db execute --stdin --schema ' + JSON.stringify(schemaPath), {
+          input: 'SELECT 1;',
+          stdio: ['pipe', 'pipe', 'pipe'],
           cwd: process.cwd(),
-        });
-        spinner.succeed("Database connection OK.");
-        dbConnected = true;
+        })
+        spinner.succeed('Database connection OK.')
+        dbConnected = true
       } catch {
-        spinner.warn("Could not connect to database. Check DATABASE_URL.");
+        spinner.warn('Could not connect to database. Check DATABASE_URL.')
       }
 
       if (dbConnected && missing === 0) {
         try {
-          spinner.start("Checking migration status...");
-          spinner.stop();
-          execSync("npx prisma migrate status", {
-            stdio: "inherit",
+          spinner.start('Checking migration status...')
+          spinner.stop()
+          execSync('npx prisma migrate status', {
+            stdio: 'inherit',
             cwd: process.cwd(),
-          });
+          })
         } catch {
-          logger.warn("Could not check migration status.");
+          logger.warn('Could not check migration status.')
         }
       }
 
-      console.log();
-    });
+      console.log()
+    })
 }

package/src/commands/db-sync.ts

@@ -0,0 +1,227 @@
+import { Command } from 'commander'
+import { access, cp, mkdir, readFile, readdir, writeFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { createRequire } from 'node:module'
+import ora from 'ora'
+import { logger } from '../utils/logger.js'
+
+const require = createRequire(import.meta.url)
+
+// Marker that identifies a schema this CLI/scaffolder owns (auto-synced from
+// cms-core). We refuse to overwrite a schema lacking it unless --force, so a
+// hand-customized schema is never silently clobbered.
+const AUTO_SYNCED_MARKER = 'AUTO-SYNCED from @actuate-media/cms-core'
+
+// Must match create-actuate-cms/scripts/sync-prisma-assets.ts `SCAFFOLD_SCHEMA_HEADER`
+// so re-syncing a scaffolded project is idempotent (no spurious diffs).
+const SCHEMA_HEADER = `// ─────────────────────────────────────────────────────────────────────────────
+// Actuate CMS — Prisma schema
+//
+// AUTO-SYNCED from @actuate-media/cms-core. Do NOT edit the model definitions
+// by hand — they must match the bundled migrations and cms-core's API layer.
+// (Generated by \`actuate db:sync\`)
+// ─────────────────────────────────────────────────────────────────────────────
+
+generator client {
+  provider        = "prisma-client"
+  output          = "../generated/prisma"
+  previewFeatures = ["fullTextSearchPostgres", "relationJoins"]
+}
+
+datasource db {
+  provider = "postgresql"
+}`
+
+/**
+ * Build the consumer's `schema.prisma` from cms-core's canonical schema: strip
+ * cms-core's own generator/datasource blocks and prepend the consumer header
+ * (client output `../generated/prisma`, no datasource `url` — supplied by
+ * `prisma.config.ts`). Pure for testing. Mirrors the scaffolder's builder.
+ */
+export function buildConsumerSchema(coreSchemaSource: string): string {
+  const datasourceMatch = coreSchemaSource.match(/datasource\s+\w+\s*\{[\s\S]*?\}/)
+  if (!datasourceMatch || datasourceMatch.index === undefined) {
+    throw new Error('Could not locate the `datasource` block in cms-core schema.prisma')
+  }
+  const body = coreSchemaSource
+    .slice(datasourceMatch.index + datasourceMatch[0].length)
+    .replace(/^\s+/, '')
+
+  if (!/@@map\("actuate_users"\)/.test(body)) {
+    throw new Error('cms-core schema body is missing `@@map("actuate_users")` — aborting sync')
+  }
+
+  return `${SCHEMA_HEADER}\n\n${body.trimEnd()}\n`
+}
+
+/**
+ * Resolve the installed `@actuate-media/cms-core` package's `prisma/` directory
+ * (the source of truth for schema + migrations). Overridable for tests.
+ */
+export let resolveCmsCorePrismaDir = (): string | null => {
+  try {
+    const exported = require.resolve('@actuate-media/cms-core/prisma/schema')
+    return dirname(exported)
+  } catch {
+    /* exports map missing the subpath — try the main entry */
+  }
+  try {
+    const mainEntry = require.resolve('@actuate-media/cms-core')
+    return join(dirname(mainEntry), '..', 'prisma')
+  } catch {
+    return null
+  }
+}
+
+const defaultPrismaDirResolver = resolveCmsCorePrismaDir
+
+export function setCmsCorePrismaDirResolver(resolver: typeof resolveCmsCorePrismaDir): void {
+  resolveCmsCorePrismaDir = resolver
+}
+
+export function resetCmsCorePrismaDirResolver(): void {
+  resolveCmsCorePrismaDir = defaultPrismaDirResolver
+}
+
+async function listMigrationDirs(dir: string): Promise<string[]> {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true })
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name)
+  } catch {
+    return []
+  }
+}
+
+interface DbSyncOptions {
+  schema: string
+  force?: boolean
+}
+
+export interface DbSyncResult {
+  schemaWritten: boolean
+  migrationsAdded: string[]
+  skippedReason?: string
+}
+
+/**
+ * Core sync logic, separated from CLI plumbing for testing. Additive for
+ * migrations (never deletes existing ones — they are immutable history), and
+ * guarded for the schema (won't overwrite a non-auto-synced schema without
+ * `force`).
+ */
+export async function syncPrismaAssets(
+  consumerSchemaPath: string,
+  corePrismaDir: string,
+  opts: { force?: boolean } = {},
+): Promise<DbSyncResult> {
+  const coreSchemaPath = join(corePrismaDir, 'schema.prisma')
+  const coreSchema = await readFile(coreSchemaPath, 'utf-8')
+  const nextSchema = buildConsumerSchema(coreSchema)
+
+  const consumerDir = dirname(consumerSchemaPath)
+  const consumerMigrationsDir = join(consumerDir, 'migrations')
+  const coreMigrationsDir = join(corePrismaDir, 'migrations')
+
+  // Guard the schema overwrite.
+  let schemaWritten = false
+  let skippedReason: string | undefined
+  const existing = existsSync(consumerSchemaPath)
+    ? await readFile(consumerSchemaPath, 'utf-8')
+    : null
+
+  if (existing && !existing.includes(AUTO_SYNCED_MARKER) && !opts.force) {
+    skippedReason =
+      'schema.prisma is not an auto-synced Actuate schema (no AUTO-SYNCED marker). Re-run with --force to overwrite it.'
+  } else {
+    await mkdir(consumerDir, { recursive: true })
+    if (existing !== nextSchema) {
+      await writeFile(consumerSchemaPath, nextSchema)
+      schemaWritten = true
+    }
+  }
+
+  // Additively copy any cms-core migrations the consumer doesn't already have.
+  const coreMigrations = await listMigrationDirs(coreMigrationsDir)
+  const existingMigrations = new Set(await listMigrationDirs(consumerMigrationsDir))
+  const migrationsAdded: string[] = []
+
+  if (coreMigrations.length > 0) {
+    await mkdir(consumerMigrationsDir, { recursive: true })
+    const lockSrc = join(coreMigrationsDir, 'migration_lock.toml')
+    const lockDest = join(consumerMigrationsDir, 'migration_lock.toml')
+    if (existsSync(lockSrc) && !existsSync(lockDest)) {
+      await cp(lockSrc, lockDest)
+    }
+    for (const name of coreMigrations) {
+      if (existingMigrations.has(name)) continue
+      await cp(join(coreMigrationsDir, name), join(consumerMigrationsDir, name), {
+        recursive: true,
+      })
+      migrationsAdded.push(name)
+    }
+  }
+
+  return { schemaWritten, migrationsAdded, skippedReason }
+}
+
+async function runDbSync(options: DbSyncOptions): Promise<void> {
+  const consumerSchemaPath = resolve(process.cwd(), options.schema)
+  const spinner = ora('Locating @actuate-media/cms-core…').start()
+
+  const corePrismaDir = resolveCmsCorePrismaDir()
+  if (!corePrismaDir) {
+    spinner.fail('Could not locate @actuate-media/cms-core.')
+    logger.info('Install it first: `npm install @actuate-media/cms-core`.')
+    process.exitCode = 1
+    return
+  }
+
+  try {
+    await access(join(corePrismaDir, 'schema.prisma'))
+  } catch {
+    spinner.fail(`cms-core does not ship a Prisma schema at ${corePrismaDir}.`)
+    process.exitCode = 1
+    return
+  }
+
+  spinner.text = 'Syncing schema + migrations…'
+  let result: DbSyncResult
+  try {
+    result = await syncPrismaAssets(consumerSchemaPath, corePrismaDir, { force: options.force })
+  } catch (err) {
+    spinner.fail('Failed to sync Prisma assets.')
+    logger.error(err instanceof Error ? err.message : String(err))
+    process.exitCode = 1
+    return
+  }
+
+  spinner.succeed('Prisma assets synced from cms-core.')
+
+  if (result.skippedReason) {
+    logger.warn(`Schema not updated: ${result.skippedReason}`)
+  } else if (result.schemaWritten) {
+    logger.success('schema.prisma refreshed.')
+  } else {
+    logger.info('schema.prisma already up to date.')
+  }
+
+  if (result.migrationsAdded.length > 0) {
+    logger.success(`Added ${result.migrationsAdded.length} new migration(s).`)
+  } else {
+    logger.info('No new migrations to add.')
+  }
+
+  if (result.schemaWritten || result.migrationsAdded.length > 0) {
+    logger.info('Next: run `npx prisma migrate deploy` then `npx prisma generate`.')
+  }
+}
+
+export function registerDbSyncCommand(program: Command): void {
+  program
+    .command('db:sync')
+    .description('Sync the canonical Prisma schema + migrations from the installed cms-core')
+    .option('--schema <path>', 'Path to schema.prisma', 'prisma/schema.prisma')
+    .option('--force', 'Overwrite schema.prisma even if it lacks the AUTO-SYNCED marker')
+    .action(runDbSync)
+}