@actuate-media/cli 0.4.0 → 0.4.2

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,23 +70,69 @@ 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({
+      schemaModels: new Set(REQUIRED_CMS_MODELS),
+      schemaContent: '',
+      configContent: `
+        export default defineConfig({
+          collections: {
+            pages: {
+              slug: 'pages',
+              fields: {
+                title: { type: 'text' },
+                slug: { type: 'slug' },
+                heroHeadline: { type: 'text' },
+                heroSubheadline: { type: 'text' },
+                heroImage: { type: 'media' },
+                bodyContent: { type: 'richText' },
+                ctaButtonText: { type: 'text' }
+              }
+            }
+          }
+        })
+      `,
+      env: {
+        DATABASE_URL: 'postgresql://example',
+        CMS_SECRET: 'secret',
+        CMS_ENCRYPTION_KEY: 'a'.repeat(64),
+        NEXT_PUBLIC_SITE_URL: 'https://example.com',
+      },
+      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',
+        }),
+      ]),
+    )
+  })
 
   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 })
+  })
+})

package/src/__tests__/seed.test.ts

@@ -1,17 +1,17 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest'
 
 vi.mock('@actuate-media/cms-core', () => ({
   extractPlainText: vi.fn((value: string) => value.replace(/<[^>]+>/g, ' ')),
   hashContent: vi.fn(async () => 'hash-1'),
   sanitizeHtml: vi.fn((value: string) => value.replace(/<script[\s\S]*?<\/script>/gi, '')),
   createInitialAdmin: vi.fn(),
-}));
+}))
 
-import { createSeedDocument, ensureSeedAdmin, normalizeSeedPayload } from '../commands/seed.js';
+import { createSeedDocument, ensureSeedAdmin, normalizeSeedPayload } from '../commands/seed.js'
 
 afterEach(() => {
-  vi.unstubAllEnvs();
-});
+  vi.unstubAllEnvs()
+})
 
 describe('seed payload normalization', () => {
   it('separates globals from collection documents', () => {
@@ -30,38 +30,38 @@ describe('seed payload normalization', () => {
           },
         ],
       },
-    });
+    })
 
     expect(normalized.globals).toEqual([
       {
         slug: 'site-settings',
         data: { siteName: 'MaidPro', phone: '555-0100' },
       },
-    ]);
+    ])
     expect(normalized.documents).toEqual([
       {
         collection: 'pages',
         data: { title: 'Home', slug: 'home' },
         status: 'PUBLISHED',
       },
-    ]);
-  });
+    ])
+  })
 
   it('keeps backwards-compatible collection-key seed files', () => {
     const normalized = normalizeSeedPayload({
       pages: [{ title: 'Home', slug: 'home' }],
-    });
+    })
 
-    expect(normalized.globals).toEqual([]);
+    expect(normalized.globals).toEqual([])
     expect(normalized.documents).toEqual([
       {
         collection: 'pages',
         data: { title: 'Home', slug: 'home' },
         status: 'DRAFT',
       },
-    ]);
-  });
-});
+    ])
+  })
+})
 
 describe('seed admin handling', () => {
   it('refuses to create a first admin without credentials', async () => {
@@ -69,11 +69,11 @@ describe('seed admin handling', () => {
       user: {
         findFirst: vi.fn().mockResolvedValue(null),
       },
-    };
+    }
 
-    await expect(ensureSeedAdmin(db)).rejects.toThrow('CMS_ADMIN_EMAIL and CMS_ADMIN_PASSWORD');
-  });
-});
+    await expect(ensureSeedAdmin(db)).rejects.toThrow('CMS_ADMIN_EMAIL and CMS_ADMIN_PASSWORD')
+  })
+})
 
 describe('seed document creation', () => {
   it('creates documents with versions, content hashes, and sanitized HTML', async () => {
@@ -84,10 +84,10 @@ describe('seed document creation', () => {
       version: {
         create: vi.fn(),
       },
-    };
+    }
     const db = {
       $transaction: vi.fn(async (fn) => fn(tx)),
-    };
+    }
 
     await createSeedDocument(db, 'admin-1', {
       collection: 'pages',
@@ -97,7 +97,7 @@ describe('seed document creation', () => {
         slug: 'home',
         content: '<p>Hello</p><script>alert(1)</script>',
       },
-    });
+    })
 
     expect(tx.document.create).toHaveBeenCalledWith({
       data: expect.objectContaining({
@@ -114,13 +114,13 @@ describe('seed document creation', () => {
           content: '<p>Hello</p>',
         }),
       }),
-    });
+    })
     expect(tx.version.create).toHaveBeenCalledWith({
       data: expect.objectContaining({
         documentId: 'doc-1',
         changedById: 'admin-1',
         changeType: 'CREATE',
       }),
-    });
-  });
-});
+    })
+  })
+})

package/src/commands/db-init.ts

@@ -1,32 +1,32 @@
-import { Command } from "commander";
-import { readFile, writeFile, access } from "node:fs/promises";
-import { resolve, join } from "node:path";
-import { execSync, type ExecSyncOptions } from "node:child_process";
-import ora from "ora";
-import { logger } from "../utils/logger.js";
+import { Command } from 'commander'
+import { readFile, writeFile, access } from 'node:fs/promises'
+import { resolve, join } from 'node:path'
+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 CMS_SCHEMA_MARKER = '// ── Actuate CMS models'
 
 export let runDbInitCommand = (command: string, options: ExecSyncOptions): void => {
-  execSync(command, options);
-};
+  execSync(command, options)
+}
 
-const defaultDbInitCommandRunner = runDbInitCommand;
+const defaultDbInitCommandRunner = runDbInitCommand
 
 export function setDbInitCommandRunner(runner: typeof runDbInitCommand): void {
-  runDbInitCommand = runner;
+  runDbInitCommand = runner
 }
 
 export function resetDbInitCommandRunner(): void {
-  runDbInitCommand = defaultDbInitCommandRunner;
+  runDbInitCommand = defaultDbInitCommandRunner
 }
 
 async function fileExists(filePath: string): Promise<boolean> {
   try {
-    await access(filePath);
-    return true;
+    await access(filePath)
+    return true
   } catch {
-    return false;
+    return false
   }
 }
 
@@ -302,83 +302,83 @@ model SavedSection {
 
   @@index([category])
 }
-`;
+`
 }
 
 export function registerDbInitCommand(program: Command): void {
   program
-    .command("db:init")
-    .description("Add Actuate CMS models to your Prisma schema and generate the client")
-    .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")
+    .command('db:init')
+    .description('Add Actuate CMS models to your Prisma schema and generate the client')
+    .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')
     .action(async (opts: { schema: string; migrate?: boolean; force?: boolean }) => {
-      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("Reading Prisma schema...").start();
+      const spinner = ora('Reading Prisma 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
       }
 
       if (content.includes(CMS_SCHEMA_MARKER)) {
         if (!opts.force) {
-          spinner.info("Actuate CMS models already present in schema. Use --force to overwrite.");
-          return;
+          spinner.info('Actuate CMS models already present in schema. Use --force to overwrite.')
+          return
         }
-        spinner.text = "Removing existing CMS models...";
-        const markerIndex = content.indexOf(CMS_SCHEMA_MARKER);
-        content = content.substring(0, markerIndex).trimEnd() + "\n";
+        spinner.text = 'Removing existing CMS models...'
+        const markerIndex = content.indexOf(CMS_SCHEMA_MARKER)
+        content = content.substring(0, markerIndex).trimEnd() + '\n'
       }
 
-      spinner.text = "Adding Actuate CMS models...";
-      const updatedContent = content.trimEnd() + "\n" + getCmsSchemaFragment();
+      spinner.text = 'Adding Actuate CMS models...'
+      const updatedContent = content.trimEnd() + '\n' + getCmsSchemaFragment()
 
       try {
-        await writeFile(schemaPath, updatedContent);
-        spinner.succeed("Actuate CMS models added to schema.");
+        await writeFile(schemaPath, updatedContent)
+        spinner.succeed('Actuate CMS models added to schema.')
       } catch (err) {
-        spinner.fail("Failed to write schema file.");
-        logger.error(err instanceof Error ? err.message : String(err));
-        process.exitCode = 1;
-        return;
+        spinner.fail('Failed to write schema file.')
+        logger.error(err instanceof Error ? err.message : String(err))
+        process.exitCode = 1
+        return
       }
 
-      const execOpts: ExecSyncOptions = { stdio: "inherit", cwd: process.cwd() };
+      const execOpts: ExecSyncOptions = { stdio: 'inherit', cwd: process.cwd() }
 
-      const genSpinner = ora("Running prisma generate...").start();
+      const genSpinner = ora('Running prisma generate...').start()
       try {
-        genSpinner.stop();
-        runDbInitCommand("npx prisma generate", execOpts);
-        logger.success("Prisma client generated.");
+        genSpinner.stop()
+        runDbInitCommand('npx prisma generate', execOpts)
+        logger.success('Prisma client generated.')
       } catch {
-        logger.warn("prisma generate failed. You may need to set DATABASE_URL first.");
+        logger.warn('prisma generate failed. You may need to set DATABASE_URL first.')
       }
 
       if (opts.migrate) {
-        const migSpinner = ora("Running prisma migrate dev...").start();
+        const migSpinner = ora('Running prisma migrate dev...').start()
         try {
-          migSpinner.stop();
-          runDbInitCommand("npx prisma migrate dev --name actuate-cms-init", execOpts);
-          logger.success("Migration created and applied.");
+          migSpinner.stop()
+          runDbInitCommand('npx prisma migrate dev --name actuate-cms-init', execOpts)
+          logger.success('Migration created and applied.')
         } catch {
-          logger.warn("prisma migrate dev failed. Run it manually after setting DATABASE_URL.");
+          logger.warn('prisma migrate dev failed. Run it manually after setting DATABASE_URL.')
         }
       } else {
-        logger.info("Run `npx prisma migrate dev --name actuate-cms` to create the migration.");
+        logger.info('Run `npx prisma migrate dev --name actuate-cms` to create the migration.')
       }
-    });
+    })
 }