@actuate-media/cli 0.4.2 → 0.5.0

package/src/commands/db-init.ts

@@ -1,12 +1,15 @@
 import { Command } from 'commander'
 import { readFile, writeFile, access } from 'node:fs/promises'
-import { resolve, join } from 'node:path'
+import { resolve, join, dirname } from 'node:path'
+import { createRequire } from 'node:module'
 import { execSync, type ExecSyncOptions } from 'node:child_process'
 import ora from 'ora'
 import { logger } from '../utils/logger.js'
 
 const CMS_SCHEMA_MARKER = '// ── Actuate CMS models'
 
+const require = createRequire(import.meta.url)
+
 export let runDbInitCommand = (command: string, options: ExecSyncOptions): void => {
   execSync(command, options)
 }
@@ -21,294 +24,108 @@ export function resetDbInitCommandRunner(): void {
   runDbInitCommand = defaultDbInitCommandRunner
 }
 
-async function fileExists(filePath: string): Promise<boolean> {
+/**
+ * Reads the canonical Prisma schema shipped by the installed
+ * `@actuate-media/cms-core` package. This is the single source of truth — it has
+ * the correct `@@map("actuate_*")` table names and every model the API handlers
+ * expect. Previously `db:init` injected a hand-maintained copy that drifted
+ * (missing `@@map`, missing models), producing a database the runtime couldn't
+ * query. Overridable for tests.
+ */
+export let readCanonicalCmsSchema = async (): Promise<string | null> => {
+  const candidates: string[] = []
   try {
-    await access(filePath)
-    return true
+    // `./prisma/schema` is an exported subpath, so this resolves inside the
+    // package's `prisma/` directory without depending on the build output.
+    const exported = require.resolve('@actuate-media/cms-core/prisma/schema')
+    candidates.push(join(dirname(exported), 'schema.prisma'))
   } catch {
-    return false
+    /* exports map missing the subpath — fall through to the main entry */
+  }
+  try {
+    const mainEntry = require.resolve('@actuate-media/cms-core')
+    candidates.push(join(dirname(mainEntry), '..', 'prisma', 'schema.prisma'))
+  } catch {
+    /* package not installed */
   }
-}
-
-function getCmsSchemaFragment(): string {
-  return `
-// ── Actuate CMS models ─────────────────────────────────────────────────────
-// Auto-injected by \`actuate db:init\`. Do not remove this marker comment.
-// Schema version: 1
-
-enum DocumentStatus {
-  DRAFT
-  PUBLISHED
-  ARCHIVED
-  SCHEDULED
-}
-
-model User {
-  id            String    @id @default(cuid())
-  email         String    @unique
-  name          String    @default("")
-  role          String    @default("EDITOR")
-  passwordHash  String?
-  isActive      Boolean   @default(true)
-  isApproved    Boolean   @default(false)
-  emailVerified Boolean   @default(false)
-  totpEnabled   Boolean   @default(false)
-  totpSecret    String?
-  backupCodes   Json?
-  oauthProvider String?
-  oauthId       String?
-  createdAt     DateTime  @default(now())
-  updatedAt     DateTime  @updatedAt
-
-  sessions          Session[]
-  documentsCreated  Document[] @relation("DocumentCreatedBy")
-  documentsUpdated  Document[] @relation("DocumentUpdatedBy")
-  documentsReviewed Document[] @relation("DocumentReviewer")
-  versions          Version[]
-  mediaUploaded     Media[]    @relation("MediaUploadedBy")
-  auditLogs         AuditLog[]
-
-  @@index([role])
-  @@index([isActive])
-}
-
-model Session {
-  id        String    @id @default(cuid())
-  userId    String
-  user      User      @relation(fields: [userId], references: [id], onDelete: Cascade)
-  token     String?   @unique
-  expiresAt DateTime
-  revokedAt DateTime?
-  ipAddress String?
-  userAgent String?
-  createdAt DateTime  @default(now())
-
-  @@index([userId])
-  @@index([expiresAt])
-}
-
-model Document {
-  id                   String          @id @default(cuid())
-  collection           String
-  slug                 String?
-  title                String?
-  data                 Json
-  status               DocumentStatus  @default(DRAFT)
-  plainText            String?         @db.Text
-  locale               String?
-  folderId             String?
-  structuredData       Json?
-  workflowStage        String?
-  reviewerId           String?
-  reviewNote           String?         @db.Text
-  publishedAt          DateTime?
-  scheduledAt          DateTime?
-  scheduledUnpublishAt DateTime?
-  deletedAt            DateTime?
-  contentHash          String?
-  siteId               String?
-  templateId           String?
-  createdById          String
-  updatedById          String
-  createdAt            DateTime        @default(now())
-  updatedAt            DateTime        @updatedAt
-
-  createdBy       User             @relation("DocumentCreatedBy", fields: [createdById], references: [id], onDelete: Restrict)
-  updatedBy       User             @relation("DocumentUpdatedBy", fields: [updatedById], references: [id], onDelete: Restrict)
-  reviewer        User?            @relation("DocumentReviewer", fields: [reviewerId], references: [id], onDelete: SetNull)
-  folder          Folder?          @relation(fields: [folderId], references: [id], onDelete: SetNull)
-  versions        Version[]
-  formSubmissions FormSubmission[]
-
-  @@unique([collection, slug], name: "collection_slug")
-  @@index([collection])
-  @@index([status])
-  @@index([deletedAt])
-  @@index([publishedAt])
-  @@index([folderId])
-  @@index([locale])
-  @@index([scheduledAt])
-  @@index([scheduledUnpublishAt])
-  @@index([createdById])
-  @@index([updatedById])
-}
-
-model Media {
-  id           String   @id @default(cuid())
-  filename     String
-  storageKey   String   @unique
-  mimeType     String
-  fileSize     Int
-  width        Int?
-  height       Int?
-  altText      String?
-  title        String?
-  blurHash     String?
-  focalPointX  Float?
-  focalPointY  Float?
-  folderId     String?
-  uploadedById String
-  createdAt    DateTime @default(now())
-  updatedAt    DateTime @updatedAt
-
-  uploadedBy User    @relation("MediaUploadedBy", fields: [uploadedById], references: [id], onDelete: Restrict)
-  folder     Folder? @relation(fields: [folderId], references: [id], onDelete: SetNull)
-
-  @@index([folderId])
-  @@index([mimeType])
-  @@index([createdAt])
-}
-
-model Version {
-  id          String   @id @default(cuid())
-  documentId  String
-  document    Document @relation(fields: [documentId], references: [id], onDelete: Cascade)
-  data        Json
-  changedById String
-  changedBy   User     @relation(fields: [changedById], references: [id], onDelete: Restrict)
-  changeType  String   @default("UPDATE")
-  createdAt   DateTime @default(now())
-
-  @@index([documentId])
-  @@index([createdAt])
-}
-
-model Folder {
-  id        String   @id @default(cuid())
-  name      String
-  scope     String
-  parentId  String?
-  position  Int      @default(0)
-  createdAt DateTime @default(now())
-
-  parent    Folder?    @relation("FolderTree", fields: [parentId], references: [id], onDelete: Cascade)
-  children  Folder[]   @relation("FolderTree")
-  documents Document[]
-  media     Media[]
 
-  @@index([scope])
-  @@index([parentId])
-  @@index([scope, parentId, position])
+  for (const candidate of candidates) {
+    try {
+      return await readFile(candidate, 'utf-8')
+    } catch {
+      /* try the next candidate */
+    }
+  }
+  return null
 }
 
-model Redirect {
-  id          String   @id @default(cuid())
-  source      String
-  destination String
-  statusCode  Int      @default(301)
-  isRegex     Boolean  @default(false)
-  notes       String?
-  createdAt   DateTime @default(now())
-  updatedAt   DateTime @updatedAt
+const defaultSchemaReader = readCanonicalCmsSchema
 
-  @@unique([source])
-  @@index([createdAt])
+export function setCanonicalSchemaReader(reader: typeof readCanonicalCmsSchema): void {
+  readCanonicalCmsSchema = reader
 }
 
-model FormSubmission {
-  id           String   @id @default(cuid())
-  formId       String
-  form         Document @relation(fields: [formId], references: [id], onDelete: Cascade)
-  data         Json
-  attribution  Json?
-  submittedAt  DateTime @default(now())
-  createdAt    DateTime @default(now())
-
-  @@index([formId])
-  @@index([submittedAt])
-  @@index([createdAt])
+export function resetCanonicalSchemaReader(): void {
+  readCanonicalCmsSchema = defaultSchemaReader
 }
 
-model AuditLog {
-  id        String   @id @default(cuid())
-  event     String
-  userId    String?
-  user      User?    @relation(fields: [userId], references: [id], onDelete: SetNull)
-  details   Json?
-  ipAddress String?
-  userAgent String?
-  createdAt DateTime @default(now())
-
-  @@index([event])
-  @@index([userId])
-  @@index([createdAt])
+function netBraces(line: string): number {
+  return (line.match(/\{/g)?.length ?? 0) - (line.match(/\}/g)?.length ?? 0)
 }
 
-model PasswordResetToken {
-  id        String    @id @default(cuid())
-  userId    String
-  tokenHash String
-  expiresAt DateTime
-  usedAt    DateTime?
-  createdAt DateTime  @default(now())
-
-  @@index([tokenHash])
-  @@index([userId])
-}
+/**
+ * Strips the top-level `generator` and `datasource` blocks from a full Prisma
+ * schema, leaving only the `enum` and `model` definitions. The consumer keeps
+ * their own datasource/generator; we only contribute models.
+ */
+export function extractModelsFragment(fullSchema: string): string {
+  const lines = fullSchema.split(/\r?\n/)
+  const kept: string[] = []
+  let skipping = false
+  let depth = 0
 
-model MediaUsage {
-  id          String   @id @default(cuid())
-  mediaId     String
-  documentId  String
-  fieldPath   String?
-  createdAt   DateTime @default(now())
-
-  @@unique([mediaId, documentId, fieldPath])
-  @@index([mediaId])
-  @@index([documentId])
-}
-
-model ScriptTag {
-  id          String   @id @default(cuid())
-  name        String
-  code        String   @db.Text
-  placement   String
-  scope       String
-  targetPaths String[]
-  priority    Int      @default(100)
-  enabled     Boolean  @default(true)
-  createdAt   DateTime @default(now())
-  updatedAt   DateTime @updatedAt
+  for (const line of lines) {
+    if (!skipping) {
+      if (/^\s*(generator|datasource)\s+[A-Za-z0-9_]+\s*\{/.test(line)) {
+        skipping = true
+        depth = netBraces(line)
+        if (depth <= 0) skipping = false
+        continue
+      }
+      kept.push(line)
+    } else {
+      depth += netBraces(line)
+      if (depth <= 0) skipping = false
+    }
+  }
 
-  @@index([enabled])
-  @@index([placement])
+  return kept.join('\n').trim()
 }
 
-model PageTemplate {
-  id          String   @id @default(cuid())
-  name        String
-  description String?
-  category    String   @default("content")
-  tree        Json
-  thumbnail   String?
-  builtIn     Boolean  @default(false)
-  createdAt   DateTime @default(now())
-  updatedAt   DateTime @updatedAt
+function wrapFragment(models: string): string {
+  return `
+${CMS_SCHEMA_MARKER} ─────────────────────────────────────────────────────────
+// Auto-injected by \`actuate db:init\` from the installed @actuate-media/cms-core
+// package's canonical prisma/schema.prisma (the single source of truth). Do not
+// edit by hand — re-run \`actuate db:init --force\` after upgrading cms-core.
 
-  @@index([category])
-  @@index([builtIn])
+${models}
+`
 }
 
-model SavedSection {
-  id          String   @id @default(cuid())
-  name        String
-  description String?
-  category    String   @default("content")
-  tree        Json
-  thumbnail   String?
-  usageCount  Int      @default(0)
-  createdAt   DateTime @default(now())
-  updatedAt   DateTime @updatedAt
-
-  @@index([category])
-}
-`
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await access(filePath)
+    return true
+  } catch {
+    return false
+  }
 }
 
 export function registerDbInitCommand(program: Command): void {
   program
     .command('db:init')
-    .description('Add Actuate CMS models to your Prisma schema and generate the client')
+    .description('Add Actuate CMS models (from the installed cms-core) to your Prisma schema')
     .option('--schema <path>', 'Path to schema.prisma', 'prisma/schema.prisma')
     .option('--migrate', 'Run prisma migrate dev after adding models')
     .option('--force', 'Overwrite existing CMS models if present')
@@ -322,8 +139,18 @@ export function registerDbInitCommand(program: Command): void {
         return
       }
 
-      const spinner = ora('Reading Prisma schema...').start()
+      const spinner = ora('Reading canonical Actuate schema...').start()
+
+      const canonical = await readCanonicalCmsSchema()
+      if (!canonical) {
+        spinner.fail('Could not locate @actuate-media/cms-core.')
+        logger.info('Install it first: `npm install @actuate-media/cms-core`.')
+        process.exitCode = 1
+        return
+      }
+      const fragment = wrapFragment(extractModelsFragment(canonical))
 
+      spinner.text = 'Reading Prisma schema...'
       let content: string
       try {
         content = await readFile(schemaPath, 'utf-8')
@@ -345,7 +172,7 @@ export function registerDbInitCommand(program: Command): void {
       }
 
       spinner.text = 'Adding Actuate CMS models...'
-      const updatedContent = content.trimEnd() + '\n' + getCmsSchemaFragment()
+      const updatedContent = content.trimEnd() + '\n' + fragment
 
       try {
         await writeFile(schemaPath, updatedContent)

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)
+}

package/src/commands/upgrade.ts

@@ -167,6 +167,14 @@ async function runUpgrade(options: UpgradeOptions): Promise<void> {
 
   logger.success(`Updated ${upgrades.length} package(s) in package.json.`)
   logger.info('Run "pnpm install" to apply the upgrade.')
+
+  // A cms-core bump can introduce new models/migrations. Bumping the version
+  // alone leaves the consumer's Prisma schema stale, so point them at db:sync.
+  if (upgrades.some((u) => u.name === '@actuate-media/cms-core')) {
+    logger.info(
+      'cms-core changed — after installing, run "actuate db:sync" then "npx prisma migrate deploy" to update your Prisma schema.',
+    )
+  }
 }
 
 export function registerUpgradeCommand(program: Command): void {

package/src/index.ts

@@ -8,6 +8,7 @@ import { registerExportCommand } from './commands/export.js'
 import { registerUpgradeCommand } from './commands/upgrade.js'
 import { registerUpdateCheckCommand } from './commands/update-check.js'
 import { registerDbInitCommand } from './commands/db-init.js'
+import { registerDbSyncCommand } from './commands/db-sync.js'
 import { registerDbStatusCommand } from './commands/db-status.js'
 import { registerInitCommand } from './commands/init.js'
 import {
@@ -31,6 +32,7 @@ registerExportCommand(program)
 registerUpgradeCommand(program)
 registerUpdateCheckCommand(program)
 registerDbInitCommand(program)
+registerDbSyncCommand(program)
 registerDbStatusCommand(program)
 registerInitCommand(program)
 registerDoctorCommand(program)