@actuate-media/cli 0.4.1 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actuate-media/cli",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "CLI for Actuate CMS — migrations, codegen, imports, exports, and upgrades",
   "repository": {
     "type": "git",
@@ -27,8 +27,8 @@
   },
   "devDependencies": {
     "typescript": "^5.7.0",
-    "vitest": "^3.0.0",
-    "@actuate-media/cms-core": "0.10.4"
+    "vitest": "^4.1.0",
+    "@actuate-media/cms-core": "0.51.0"
   },
   "scripts": {
     "build": "tsc",

package/src/__tests__/db-init.test.ts

@@ -0,0 +1,155 @@
+import { Command } from 'commander'
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import {
+  extractModelsFragment,
+  registerDbInitCommand,
+  resetCanonicalSchemaReader,
+  resetDbInitCommandRunner,
+  setCanonicalSchemaReader,
+  setDbInitCommandRunner,
+} from '../commands/db-init.js'
+
+const FULL_SCHEMA = `generator client {
+  provider        = "prisma-client"
+  output          = "../generated"
+  previewFeatures = ["relationJoins"]
+}
+
+datasource db {
+  provider = "postgresql"
+}
+
+enum DocumentStatus {
+  DRAFT
+  PUBLISHED
+}
+
+model Document {
+  id         String         @id @default(cuid())
+  collection String
+  status     DocumentStatus @default(DRAFT)
+
+  @@index([collection])
+  @@map("actuate_documents")
+}
+
+model User {
+  id    String @id @default(cuid())
+  email String @unique
+
+  @@map("actuate_users")
+}
+`
+
+function consumerSchema() {
+  return `generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+`
+}
+
+describe('db:init (WS-D D5 — canonical schema, no stale fragment)', () => {
+  afterEach(() => {
+    resetDbInitCommandRunner()
+    resetCanonicalSchemaReader()
+    vi.restoreAllMocks()
+  })
+
+  describe('extractModelsFragment', () => {
+    it('strips generator and datasource blocks but keeps enums + models', () => {
+      const fragment = extractModelsFragment(FULL_SCHEMA)
+      expect(fragment).not.toMatch(/generator\s+\w+\s*\{/)
+      expect(fragment).not.toMatch(/datasource\s+\w+\s*\{/)
+      expect(fragment).toContain('enum DocumentStatus')
+      expect(fragment).toContain('model Document')
+      expect(fragment).toContain('model User')
+      // The whole point of D5: real @@map names survive.
+      expect(fragment).toContain('@@map("actuate_documents")')
+      expect(fragment).toContain('@@map("actuate_users")')
+    })
+  })
+
+  describe('command', () => {
+    it('injects canonical models with @@map and no duplicate datasource/generator', async () => {
+      const tempRoot = await mkdtemp(path.join(tmpdir(), 'actuate-db-init-d5-'))
+      const schemaPath = path.join(tempRoot, 'schema.prisma')
+      await writeFile(schemaPath, consumerSchema())
+
+      vi.spyOn(process, 'cwd').mockReturnValue(tempRoot)
+      setDbInitCommandRunner(() => undefined)
+      setCanonicalSchemaReader(async () => FULL_SCHEMA)
+
+      const command = new Command()
+      registerDbInitCommand(command)
+      await command.parseAsync(['node', 'actuate', 'db:init', '--schema', 'schema.prisma'])
+
+      const result = await readFile(schemaPath, 'utf-8')
+      const injected = result.slice(result.indexOf('// ── Actuate CMS models'))
+
+      // The consumer keeps exactly one datasource/generator (their own).
+      expect(result.match(/datasource\s+\w+\s*\{/g)).toHaveLength(1)
+      expect(result.match(/generator\s+\w+\s*\{/g)).toHaveLength(1)
+      // Injected portion carries the canonical mapped models.
+      expect(injected).toContain('@@map("actuate_documents")')
+      expect(injected).toContain('model Document')
+      expect(injected).not.toMatch(/datasource\s+\w+\s*\{/)
+
+      await rm(tempRoot, { recursive: true, force: true })
+    })
+
+    it('fails clearly when cms-core cannot be located', async () => {
+      const tempRoot = await mkdtemp(path.join(tmpdir(), 'actuate-db-init-missing-'))
+      const schemaPath = path.join(tempRoot, 'schema.prisma')
+      await writeFile(schemaPath, consumerSchema())
+
+      vi.spyOn(process, 'cwd').mockReturnValue(tempRoot)
+      setDbInitCommandRunner(() => undefined)
+      setCanonicalSchemaReader(async () => null)
+
+      const command = new Command()
+      registerDbInitCommand(command)
+      await command.parseAsync(['node', 'actuate', 'db:init', '--schema', 'schema.prisma'])
+
+      // Schema must be left untouched (no stale fragment written).
+      const result = await readFile(schemaPath, 'utf-8')
+      expect(result).toBe(consumerSchema())
+      expect(process.exitCode).toBe(1)
+      process.exitCode = 0
+
+      await rm(tempRoot, { recursive: true, force: true })
+    })
+
+    it('is idempotent without --force', async () => {
+      const tempRoot = await mkdtemp(path.join(tmpdir(), 'actuate-db-init-idem-'))
+      const schemaPath = path.join(tempRoot, 'schema.prisma')
+      await writeFile(schemaPath, consumerSchema())
+
+      vi.spyOn(process, 'cwd').mockReturnValue(tempRoot)
+      setDbInitCommandRunner(() => undefined)
+      setCanonicalSchemaReader(async () => FULL_SCHEMA)
+
+      const command1 = new Command()
+      registerDbInitCommand(command1)
+      await command1.parseAsync(['node', 'actuate', 'db:init', '--schema', 'schema.prisma'])
+      const first = await readFile(schemaPath, 'utf-8')
+
+      const command2 = new Command()
+      registerDbInitCommand(command2)
+      await command2.parseAsync(['node', 'actuate', 'db:init', '--schema', 'schema.prisma'])
+      const second = await readFile(schemaPath, 'utf-8')
+
+      expect(second).toBe(first)
+
+      await rm(tempRoot, { recursive: true, force: true })
+    })
+  })
+})

package/src/__tests__/db-sync.test.ts

@@ -0,0 +1,167 @@
+import { mkdtemp, mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+
+import { buildConsumerSchema, syncPrismaAssets } from '../commands/db-sync.js'
+
+const CORE_SCHEMA = `generator client {
+  provider = "prisma-client"
+  output   = "../generated"
+}
+
+datasource db {
+  provider = "postgresql"
+}
+
+enum DocumentStatus {
+  DRAFT
+  PUBLISHED
+}
+
+model User {
+  id    String @id @default(cuid())
+  email String @unique
+
+  @@map("actuate_users")
+}
+
+model Document {
+  id     String         @id @default(cuid())
+  status DocumentStatus @default(DRAFT)
+
+  @@map("actuate_documents")
+}
+`
+
+async function makeCorePrismaDir(migrations: string[]): Promise<string> {
+  const dir = await mkdtemp(path.join(tmpdir(), 'core-prisma-'))
+  await writeFile(path.join(dir, 'schema.prisma'), CORE_SCHEMA)
+  const migrationsDir = path.join(dir, 'migrations')
+  await mkdir(migrationsDir, { recursive: true })
+  await writeFile(path.join(migrationsDir, 'migration_lock.toml'), 'provider = "postgresql"\n')
+  for (const m of migrations) {
+    await mkdir(path.join(migrationsDir, m), { recursive: true })
+    await writeFile(path.join(migrationsDir, m, 'migration.sql'), `-- ${m}\n`)
+  }
+  return dir
+}
+
+describe('db:sync (WS-D D2 — post-upgrade schema sync)', () => {
+  const temps: string[] = []
+  afterEach(async () => {
+    await Promise.all(temps.map((t) => rm(t, { recursive: true, force: true })))
+    temps.length = 0
+  })
+
+  describe('buildConsumerSchema', () => {
+    it('strips cms-core generator/datasource and emits the consumer header', () => {
+      const schema = buildConsumerSchema(CORE_SCHEMA)
+      expect(schema).toContain('AUTO-SYNCED from @actuate-media/cms-core')
+      expect(schema).toContain('output          = "../generated/prisma"')
+      // The cms-core generator output path must not leak through.
+      expect(schema).not.toContain('output   = "../generated"')
+      // Exactly one datasource/generator (the consumer header).
+      expect(schema.match(/generator\s+\w+\s*\{/g)).toHaveLength(1)
+      expect(schema.match(/datasource\s+\w+\s*\{/g)).toHaveLength(1)
+      expect(schema).toContain('@@map("actuate_users")')
+      expect(schema).toContain('@@map("actuate_documents")')
+    })
+
+    it('throws if the cms-core body lost its @@map names', () => {
+      const broken = CORE_SCHEMA.replace('@@map("actuate_users")', '')
+      expect(() => buildConsumerSchema(broken)).toThrow(/actuate_users/)
+    })
+  })
+
+  describe('syncPrismaAssets', () => {
+    it('refreshes an auto-synced schema and adds missing migrations', async () => {
+      const coreDir = await makeCorePrismaDir(['0001_init', '0002_new'])
+      const projectDir = await mkdtemp(path.join(tmpdir(), 'consumer-'))
+      temps.push(coreDir, projectDir)
+
+      const prismaDir = path.join(projectDir, 'prisma')
+      await mkdir(path.join(prismaDir, 'migrations', '0001_init'), { recursive: true })
+      await writeFile(
+        path.join(prismaDir, 'migrations', '0001_init', 'migration.sql'),
+        '-- already here\n',
+      )
+      // An auto-synced (stale) schema.
+      await writeFile(
+        path.join(prismaDir, 'schema.prisma'),
+        '// AUTO-SYNCED from @actuate-media/cms-core\nmodel Old {}\n',
+      )
+
+      const result = await syncPrismaAssets(path.join(prismaDir, 'schema.prisma'), coreDir)
+
+      expect(result.schemaWritten).toBe(true)
+      expect(result.migrationsAdded).toEqual(['0002_new'])
+      expect(result.skippedReason).toBeUndefined()
+
+      const schema = await readFile(path.join(prismaDir, 'schema.prisma'), 'utf-8')
+      expect(schema).toContain('@@map("actuate_users")')
+
+      // The pre-existing migration is untouched (immutable history preserved).
+      const existing = await readFile(
+        path.join(prismaDir, 'migrations', '0001_init', 'migration.sql'),
+        'utf-8',
+      )
+      expect(existing).toBe('-- already here\n')
+      const dirs = (await readdir(path.join(prismaDir, 'migrations'), { withFileTypes: true }))
+        .filter((e) => e.isDirectory())
+        .map((e) => e.name)
+        .sort()
+      expect(dirs).toEqual(['0001_init', '0002_new'])
+    })
+
+    it('refuses to overwrite a customized (non-auto-synced) schema without --force', async () => {
+      const coreDir = await makeCorePrismaDir(['0001_init'])
+      const projectDir = await mkdtemp(path.join(tmpdir(), 'consumer-custom-'))
+      temps.push(coreDir, projectDir)
+
+      const schemaPath = path.join(projectDir, 'prisma', 'schema.prisma')
+      await mkdir(path.dirname(schemaPath), { recursive: true })
+      const custom = 'datasource db {\n  provider = "postgresql"\n}\n\nmodel MyThing {}\n'
+      await writeFile(schemaPath, custom)
+
+      const result = await syncPrismaAssets(schemaPath, coreDir)
+
+      expect(result.schemaWritten).toBe(false)
+      expect(result.skippedReason).toMatch(/AUTO-SYNCED/)
+      // Custom schema untouched...
+      expect(await readFile(schemaPath, 'utf-8')).toBe(custom)
+      // ...but migrations are still synced additively.
+      expect(result.migrationsAdded).toEqual(['0001_init'])
+    })
+
+    it('overwrites a customized schema when --force is set', async () => {
+      const coreDir = await makeCorePrismaDir(['0001_init'])
+      const projectDir = await mkdtemp(path.join(tmpdir(), 'consumer-force-'))
+      temps.push(coreDir, projectDir)
+
+      const schemaPath = path.join(projectDir, 'prisma', 'schema.prisma')
+      await mkdir(path.dirname(schemaPath), { recursive: true })
+      await writeFile(schemaPath, 'model MyThing {}\n')
+
+      const result = await syncPrismaAssets(schemaPath, coreDir, { force: true })
+
+      expect(result.schemaWritten).toBe(true)
+      expect(await readFile(schemaPath, 'utf-8')).toContain('@@map("actuate_users")')
+    })
+
+    it('is idempotent — a second run writes nothing', async () => {
+      const coreDir = await makeCorePrismaDir(['0001_init'])
+      const projectDir = await mkdtemp(path.join(tmpdir(), 'consumer-idem-'))
+      temps.push(coreDir, projectDir)
+
+      const schemaPath = path.join(projectDir, 'prisma', 'schema.prisma')
+      const first = await syncPrismaAssets(schemaPath, coreDir)
+      expect(first.schemaWritten).toBe(true)
+      expect(first.migrationsAdded).toEqual(['0001_init'])
+
+      const second = await syncPrismaAssets(schemaPath, coreDir)
+      expect(second.schemaWritten).toBe(false)
+      expect(second.migrationsAdded).toEqual([])
+    })
+  })
+})

package/src/__tests__/deployment-diagnostics.test.ts

@@ -1,31 +1,33 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it } from 'vitest'
 
 import {
   buildDeploymentManifest,
   createDiagnosticReport,
   REQUIRED_CMS_MODELS,
   REQUIRED_ENV_VARS,
-} from '../deployment/diagnostics.js';
+} from '../deployment/diagnostics.js'
 
 describe('deployment diagnostics', () => {
   it('tracks deploy-critical models used by first-run admin features', () => {
-    expect(REQUIRED_CMS_MODELS).toEqual(expect.arrayContaining([
-      'User',
-      'Session',
-      'Document',
-      'Media',
-      'Version',
-      'Folder',
-      'Redirect',
-      'FormSubmission',
-      'AuditLog',
-      'PasswordResetToken',
-      'MediaUsage',
-      'ScriptTag',
-      'PageTemplate',
-      'SavedSection',
-    ]));
-  });
+    expect(REQUIRED_CMS_MODELS).toEqual(
+      expect.arrayContaining([
+        'User',
+        'Session',
+        'Document',
+        'Media',
+        'Version',
+        'Folder',
+        'Redirect',
+        'FormSubmission',
+        'AuditLog',
+        'PasswordResetToken',
+        'MediaUsage',
+        'ScriptTag',
+        'PageTemplate',
+        'SavedSection',
+      ]),
+    )
+  })
 
   it('reports missing models and env vars with exact fix commands', () => {
     const report = createDiagnosticReport({
@@ -36,22 +38,24 @@ describe('deployment diagnostics', () => {
       },
       packageManager: 'pnpm',
       schemaPath: 'prisma/schema.prisma',
-    });
+    })
 
-    expect(report.status).toBe('fail');
-    expect(report.checks).toEqual(expect.arrayContaining([
-      expect.objectContaining({
-        id: 'schema-models',
-        status: 'fail',
-        fix: 'Run `actuate db:init --schema prisma/schema.prisma` for new schemas, or update the existing Actuate block from the database setup docs, then create and apply a Prisma migration.',
-      }),
-      expect.objectContaining({
-        id: 'environment',
-        status: 'fail',
-        fix: 'Set missing environment variables before deploying: CMS_SECRET, CMS_ENCRYPTION_KEY, NEXT_PUBLIC_SITE_URL.',
-      }),
-    ]));
-  });
+    expect(report.status).toBe('fail')
+    expect(report.checks).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: 'schema-models',
+          status: 'fail',
+          fix: 'Run `actuate db:init --schema prisma/schema.prisma` for new schemas, or update the existing Actuate block from the database setup docs, then create and apply a Prisma migration.',
+        }),
+        expect.objectContaining({
+          id: 'environment',
+          status: 'fail',
+          fix: 'Set missing environment variables before deploying: CMS_SECRET, CMS_ENCRYPTION_KEY, NEXT_PUBLIC_SITE_URL.',
+        }),
+      ]),
+    )
+  })
 
   it('requires migration connection details for deploy checks', () => {
     const report = createDiagnosticReport({
@@ -66,16 +70,18 @@ describe('deployment diagnostics', () => {
       packageManager: 'pnpm',
       schemaPath: 'prisma/schema.prisma',
       mode: 'deploy',
-    });
+    })
 
-    expect(report.status).toBe('fail');
-    expect(report.checks).toEqual(expect.arrayContaining([
-      expect.objectContaining({
-        id: 'environment',
-        message: expect.stringContaining('DIRECT_DATABASE_URL'),
-      }),
-    ]));
-  });
+    expect(report.status).toBe('fail')
+    expect(report.checks).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: 'environment',
+          message: expect.stringContaining('DIRECT_DATABASE_URL'),
+        }),
+      ]),
+    )
+  })
 
   it('warns when designed marketing pages appear to use flat fields instead of page-builder content', () => {
     const report = createDiagnosticReport({
@@ -107,24 +113,26 @@ describe('deployment diagnostics', () => {
       },
       packageManager: 'pnpm',
       schemaPath: 'prisma/schema.prisma',
-    });
+    })
 
-    expect(report.status).toBe('warn');
-    expect(report.checks).toEqual(expect.arrayContaining([
-      expect.objectContaining({
-        id: 'design-first-page-builder',
-        status: 'warn',
-        docs: 'https://actuatecms.dev/docs/design-first-page-builder',
-      }),
-    ]));
-  });
+    expect(report.status).toBe('warn')
+    expect(report.checks).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: 'design-first-page-builder',
+          status: 'warn',
+          docs: 'https://actuatecms.dev/docs/design-first-page-builder',
+        }),
+      ]),
+    )
+  })
 
   it('exposes machine-readable deployment metadata', () => {
-    const manifest = buildDeploymentManifest();
+    const manifest = buildDeploymentManifest()
 
-    expect(manifest.requiredModels).toEqual(REQUIRED_CMS_MODELS);
-    expect(manifest.requiredEnv).toEqual(REQUIRED_ENV_VARS);
-    expect(manifest.routes.apiHealth).toBe('/api/cms/health');
-    expect(manifest.crons.scheduledPublish).toBe('/api/cms/cron/publish');
-  });
-});
+    expect(manifest.requiredModels).toEqual(REQUIRED_CMS_MODELS)
+    expect(manifest.requiredEnv).toEqual(REQUIRED_ENV_VARS)
+    expect(manifest.routes.apiHealth).toBe('/api/cms/health')
+    expect(manifest.crons.scheduledPublish).toBe('/api/cms/cron/publish')
+  })
+})

package/src/__tests__/init.test.ts

@@ -1,30 +1,30 @@
-import { readFile } from 'node:fs/promises';
-import { Command } from 'commander';
-import { describe, expect, it } from 'vitest';
+import { readFile } from 'node:fs/promises'
+import { Command } from 'commander'
+import { describe, expect, it } from 'vitest'
 
-import { buildCreateActuateArgs, registerInitCommand } from '../commands/init.js';
+import { buildCreateActuateArgs, registerInitCommand } from '../commands/init.js'
 
 describe('init command', () => {
   it('registers an init command that delegates to create-actuate-cms', () => {
-    const program = new Command();
-    registerInitCommand(program);
+    const program = new Command()
+    registerInitCommand(program)
 
-    const command = program.commands.find((candidate) => candidate.name() === 'init');
+    const command = program.commands.find((candidate) => candidate.name() === 'init')
 
-    expect(command).toBeDefined();
-    expect(buildCreateActuateArgs()).toEqual(['create', 'actuate-cms@latest']);
+    expect(command).toBeDefined()
+    expect(buildCreateActuateArgs()).toEqual(['create', 'actuate-cms@latest'])
     expect(buildCreateActuateArgs('maidpro-site')).toEqual([
       'create',
       'actuate-cms@latest',
       'maidpro-site',
-    ]);
-  });
+    ])
+  })
 
   it('exposes an actuate-cms bin alias for installed CLI usage', async () => {
-    const raw = await readFile(new URL('../../package.json', import.meta.url), 'utf-8');
-    const pkg = JSON.parse(raw) as { bin?: Record<string, string> };
+    const raw = await readFile(new URL('../../package.json', import.meta.url), 'utf-8')
+    const pkg = JSON.parse(raw) as { bin?: Record<string, string> }
 
-    expect(pkg.bin?.actuate).toBe('dist/index.js');
-    expect(pkg.bin?.['actuate-cms']).toBe('dist/index.js');
-  });
-});
+    expect(pkg.bin?.actuate).toBe('dist/index.js')
+    expect(pkg.bin?.['actuate-cms']).toBe('dist/index.js')
+  })
+})

package/src/__tests__/schema-fragment.test.ts

@@ -1,11 +1,15 @@
-import { Command } from 'commander';
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import { registerDbInitCommand, resetDbInitCommandRunner, setDbInitCommandRunner } from '../commands/db-init.js';
-import { REQUIRED_CMS_MODELS } from '../deployment/diagnostics.js';
+import { Command } from 'commander'
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import {
+  registerDbInitCommand,
+  resetDbInitCommandRunner,
+  setDbInitCommandRunner,
+} from '../commands/db-init.js'
+import { REQUIRED_CMS_MODELS } from '../deployment/diagnostics.js'
 
 function baseSchema() {
   return `generator client {
@@ -16,32 +20,32 @@ datasource db {
   provider = "postgresql"
   url      = env("DATABASE_URL")
 }
-`;
+`
 }
 
 describe('db:init schema fragment', () => {
   afterEach(() => {
-    resetDbInitCommandRunner();
-    vi.restoreAllMocks();
-  });
+    resetDbInitCommandRunner()
+    vi.restoreAllMocks()
+  })
 
   it('injects all deploy-critical Actuate models', async () => {
-    const tempRoot = await mkdtemp(path.join(tmpdir(), 'actuate-db-init-'));
-    const schemaPath = path.join(tempRoot, 'schema.prisma');
-    await writeFile(schemaPath, baseSchema());
+    const tempRoot = await mkdtemp(path.join(tmpdir(), 'actuate-db-init-'))
+    const schemaPath = path.join(tempRoot, 'schema.prisma')
+    await writeFile(schemaPath, baseSchema())
 
-    vi.spyOn(process, 'cwd').mockReturnValue(tempRoot);
-    setDbInitCommandRunner(() => undefined);
-    const command = new Command();
-    registerDbInitCommand(command);
+    vi.spyOn(process, 'cwd').mockReturnValue(tempRoot)
+    setDbInitCommandRunner(() => undefined)
+    const command = new Command()
+    registerDbInitCommand(command)
 
-    await command.parseAsync(['node', 'actuate', 'db:init', '--schema', 'schema.prisma']);
+    await command.parseAsync(['node', 'actuate', 'db:init', '--schema', 'schema.prisma'])
 
-    const schema = await readFile(schemaPath, 'utf-8');
+    const schema = await readFile(schemaPath, 'utf-8')
     for (const model of REQUIRED_CMS_MODELS) {
-      expect(schema).toContain(`model ${model} `);
+      expect(schema).toContain(`model ${model} `)
     }
 
-    await rm(tempRoot, { recursive: true, force: true });
-  });
-});
+    await rm(tempRoot, { recursive: true, force: true })
+  })
+})