@actuate-media/cli 0.4.0 → 0.4.2

package/src/commands/seed.ts

@@ -1,414 +1,408 @@
-import { Command } from "commander";
-import { readFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { createRequire } from "node:module";
-import path from "node:path";
-import { createInterface } from "node:readline/promises";
-import { pathToFileURL } from "node:url";
-import ora from "ora";
-import { logger } from "../utils/logger.js";
+import { Command } from 'commander'
+import { readFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { createInterface } from 'node:readline/promises'
+import { pathToFileURL } from 'node:url'
+import ora from 'ora'
+import { logger } from '../utils/logger.js'
 
 async function confirm(question: string): Promise<boolean> {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await rl.question(`${question} (y/N) `);
-  rl.close();
-  return answer.trim().toLowerCase() === "y";
+  const rl = createInterface({ input: process.stdin, output: process.stdout })
+  const answer = await rl.question(`${question} (y/N) `)
+  rl.close()
+  return answer.trim().toLowerCase() === 'y'
 }
 
 const DEMO_PAGES = [
   {
-    title: "Home",
-    slug: "home",
-    content: "<h1>Welcome</h1><p>Your homepage content goes here.</p>",
+    title: 'Home',
+    slug: 'home',
+    content: '<h1>Welcome</h1><p>Your homepage content goes here.</p>',
   },
   {
-    title: "About",
-    slug: "about",
-    content:
-      "<h1>About Us</h1><p>Learn more about our team and mission.</p>",
+    title: 'About',
+    slug: 'about',
+    content: '<h1>About Us</h1><p>Learn more about our team and mission.</p>',
   },
   {
-    title: "Contact",
-    slug: "contact",
-    content:
-      "<h1>Contact</h1><p>Get in touch with us via the form below.</p>",
+    title: 'Contact',
+    slug: 'contact',
+    content: '<h1>Contact</h1><p>Get in touch with us via the form below.</p>',
   },
   {
-    title: "Privacy Policy",
-    slug: "privacy-policy",
-    content:
-      "<h1>Privacy Policy</h1><p>Your privacy matters to us. Read our full policy.</p>",
+    title: 'Privacy Policy',
+    slug: 'privacy-policy',
+    content: '<h1>Privacy Policy</h1><p>Your privacy matters to us. Read our full policy.</p>',
   },
   {
-    title: "Terms of Service",
-    slug: "terms",
-    content:
-      "<h1>Terms of Service</h1><p>Please read the following terms carefully.</p>",
+    title: 'Terms of Service',
+    slug: 'terms',
+    content: '<h1>Terms of Service</h1><p>Please read the following terms carefully.</p>',
   },
-];
+]
 
 const DEMO_POSTS = [
   {
-    title: "Getting Started with Actuate CMS",
-    slug: "getting-started",
-    excerpt: "Learn how to set up and configure your new CMS.",
+    title: 'Getting Started with Actuate CMS',
+    slug: 'getting-started',
+    excerpt: 'Learn how to set up and configure your new CMS.',
     content:
-      "<h1>Getting Started</h1><p>Welcome to Actuate CMS. This guide walks you through initial setup.</p>",
-    status: "PUBLISHED",
+      '<h1>Getting Started</h1><p>Welcome to Actuate CMS. This guide walks you through initial setup.</p>',
+    status: 'PUBLISHED',
   },
   {
-    title: "Content Modeling Best Practices",
-    slug: "content-modeling",
-    excerpt: "Design your collections and fields for maximum flexibility.",
+    title: 'Content Modeling Best Practices',
+    slug: 'content-modeling',
+    excerpt: 'Design your collections and fields for maximum flexibility.',
     content:
-      "<h1>Content Modeling</h1><p>Effective content modeling is the foundation of a great CMS.</p>",
-    status: "PUBLISHED",
+      '<h1>Content Modeling</h1><p>Effective content modeling is the foundation of a great CMS.</p>',
+    status: 'PUBLISHED',
   },
   {
-    title: "Working with Media",
-    slug: "working-with-media",
-    excerpt: "Upload, organize, and optimize your media assets.",
-    content:
-      "<h1>Working with Media</h1><p>Actuate CMS provides powerful media management.</p>",
-    status: "PUBLISHED",
+    title: 'Working with Media',
+    slug: 'working-with-media',
+    excerpt: 'Upload, organize, and optimize your media assets.',
+    content: '<h1>Working with Media</h1><p>Actuate CMS provides powerful media management.</p>',
+    status: 'PUBLISHED',
   },
   {
-    title: "SEO Optimization Tips",
-    slug: "seo-optimization",
-    excerpt: "Boost your search rankings with built-in SEO tools.",
-    content:
-      "<h1>SEO Optimization</h1><p>Follow these tips to improve your site visibility.</p>",
-    status: "PUBLISHED",
+    title: 'SEO Optimization Tips',
+    slug: 'seo-optimization',
+    excerpt: 'Boost your search rankings with built-in SEO tools.',
+    content: '<h1>SEO Optimization</h1><p>Follow these tips to improve your site visibility.</p>',
+    status: 'PUBLISHED',
   },
   {
-    title: "Building Custom Plugins",
-    slug: "building-plugins",
-    excerpt: "Extend Actuate CMS with your own plugins.",
-    content:
-      "<h1>Building Plugins</h1><p>The plugin system lets you add custom functionality.</p>",
-    status: "PUBLISHED",
+    title: 'Building Custom Plugins',
+    slug: 'building-plugins',
+    excerpt: 'Extend Actuate CMS with your own plugins.',
+    content: '<h1>Building Plugins</h1><p>The plugin system lets you add custom functionality.</p>',
+    status: 'PUBLISHED',
   },
   {
-    title: "API Reference Overview",
-    slug: "api-reference",
-    excerpt: "A comprehensive guide to the Actuate CMS REST API.",
-    content:
-      "<h1>API Reference</h1><p>Use the API to integrate your content anywhere.</p>",
-    status: "PUBLISHED",
+    title: 'API Reference Overview',
+    slug: 'api-reference',
+    excerpt: 'A comprehensive guide to the Actuate CMS REST API.',
+    content: '<h1>API Reference</h1><p>Use the API to integrate your content anywhere.</p>',
+    status: 'PUBLISHED',
   },
   {
-    title: "Deployment Guide",
-    slug: "deployment-guide",
-    excerpt: "Deploy Actuate CMS to Vercel, AWS, or self-hosted.",
-    content:
-      "<h1>Deployment Guide</h1><p>Multiple deployment options for every use case.</p>",
-    status: "PUBLISHED",
+    title: 'Deployment Guide',
+    slug: 'deployment-guide',
+    excerpt: 'Deploy Actuate CMS to Vercel, AWS, or self-hosted.',
+    content: '<h1>Deployment Guide</h1><p>Multiple deployment options for every use case.</p>',
+    status: 'PUBLISHED',
   },
   {
-    title: "Multi-language Content",
-    slug: "multi-language",
-    excerpt: "Set up localization and manage translated content.",
+    title: 'Multi-language Content',
+    slug: 'multi-language',
+    excerpt: 'Set up localization and manage translated content.',
     content:
-      "<h1>Multi-language Content</h1><p>Reach a global audience with localized content.</p>",
-    status: "PUBLISHED",
+      '<h1>Multi-language Content</h1><p>Reach a global audience with localized content.</p>',
+    status: 'PUBLISHED',
   },
   {
-    title: "Webhooks and Integrations",
-    slug: "webhooks-integrations",
-    excerpt: "Connect Actuate CMS to external services with webhooks.",
-    content:
-      "<h1>Webhooks</h1><p>Automate workflows by connecting to third-party services.</p>",
-    status: "DRAFT",
+    title: 'Webhooks and Integrations',
+    slug: 'webhooks-integrations',
+    excerpt: 'Connect Actuate CMS to external services with webhooks.',
+    content: '<h1>Webhooks</h1><p>Automate workflows by connecting to third-party services.</p>',
+    status: 'DRAFT',
   },
   {
-    title: "Advanced Access Control",
-    slug: "access-control",
-    excerpt: "Fine-tune permissions with role-based access control.",
-    content:
-      "<h1>Access Control</h1><p>Protect your content with granular permissions.</p>",
-    status: "DRAFT",
+    title: 'Advanced Access Control',
+    slug: 'access-control',
+    excerpt: 'Fine-tune permissions with role-based access control.',
+    content: '<h1>Access Control</h1><p>Protect your content with granular permissions.</p>',
+    status: 'DRAFT',
   },
-];
+]
 
 const DEMO_FORMS = [
   {
-    title: "Contact Form",
-    slug: "contact-form",
+    title: 'Contact Form',
+    slug: 'contact-form',
     fields: [
-      { name: "name", type: "text", required: true },
-      { name: "email", type: "email", required: true },
-      { name: "message", type: "textarea", required: true },
+      { name: 'name', type: 'text', required: true },
+      { name: 'email', type: 'email', required: true },
+      { name: 'message', type: 'textarea', required: true },
     ],
-    submitLabel: "Send Message",
+    submitLabel: 'Send Message',
     successMessage: "Thanks for reaching out! We'll get back to you soon.",
   },
   {
-    title: "Newsletter Signup",
-    slug: "newsletter",
+    title: 'Newsletter Signup',
+    slug: 'newsletter',
     fields: [
-      { name: "email", type: "email", required: true },
-      { name: "firstName", type: "text", required: false },
+      { name: 'email', type: 'email', required: true },
+      { name: 'firstName', type: 'text', required: false },
     ],
-    submitLabel: "Subscribe",
+    submitLabel: 'Subscribe',
     successMessage: "You're subscribed! Check your inbox for confirmation.",
   },
   {
-    title: "Feedback Form",
-    slug: "feedback",
+    title: 'Feedback Form',
+    slug: 'feedback',
     fields: [
-      { name: "name", type: "text", required: false },
-      { name: "rating", type: "select", options: ["1", "2", "3", "4", "5"], required: true },
-      { name: "comments", type: "textarea", required: false },
+      { name: 'name', type: 'text', required: false },
+      { name: 'rating', type: 'select', options: ['1', '2', '3', '4', '5'], required: true },
+      { name: 'comments', type: 'textarea', required: false },
     ],
-    submitLabel: "Submit Feedback",
-    successMessage: "Thank you for your feedback!",
+    submitLabel: 'Submit Feedback',
+    successMessage: 'Thank you for your feedback!',
   },
-];
+]
 
 const DEMO_USERS = [
-  { email: "editor@example.com", name: "Demo Editor", role: "EDITOR" as const },
-  { email: "author@example.com", name: "Demo Author", role: "AUTHOR" as const },
-];
+  { email: 'editor@example.com', name: 'Demo Editor', role: 'EDITOR' as const },
+  { email: 'author@example.com', name: 'Demo Author', role: 'AUTHOR' as const },
+]
 
 interface SeedOptions {
-  demo?: boolean;
-  file?: string;
-  reset?: boolean;
+  demo?: boolean
+  file?: string
+  reset?: boolean
 }
 
 export interface NormalizedSeedDocument {
-  collection: string;
-  data: Record<string, unknown>;
-  status: string;
+  collection: string
+  data: Record<string, unknown>
+  status: string
 }
 
 export interface NormalizedSeedGlobal {
-  slug: string;
-  data: Record<string, unknown>;
+  slug: string
+  data: Record<string, unknown>
 }
 
 export interface NormalizedSeedPayload {
-  documents: NormalizedSeedDocument[];
-  globals: NormalizedSeedGlobal[];
+  documents: NormalizedSeedDocument[]
+  globals: NormalizedSeedGlobal[]
 }
 
 const SEED_FILE_CANDIDATES = [
-  "actuate.seed.json",
-  "actuate.seed.ts",
-  "actuate.seed.js",
-  "actuate.seed.mjs",
-  "cms.seed.json",
-];
+  'actuate.seed.json',
+  'actuate.seed.ts',
+  'actuate.seed.js',
+  'actuate.seed.mjs',
+  'cms.seed.json',
+]
 
 function asRecord(value: unknown): Record<string, unknown> {
-  return value && typeof value === "object" && !Array.isArray(value)
-    ? value as Record<string, unknown>
-    : {};
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {}
 }
 
 function normalizeDocument(collection: string, doc: unknown): NormalizedSeedDocument {
-  const record = asRecord(doc);
+  const record = asRecord(doc)
   return {
     collection,
     data: asRecord(record.data ?? record),
-    status: typeof record.status === "string" ? record.status : "DRAFT",
-  };
+    status: typeof record.status === 'string' ? record.status : 'DRAFT',
+  }
 }
 
 export function normalizeSeedPayload(seedData: unknown): NormalizedSeedPayload {
-  const documents: NormalizedSeedDocument[] = [];
-  const globals: NormalizedSeedGlobal[] = [];
+  const documents: NormalizedSeedDocument[] = []
+  const globals: NormalizedSeedGlobal[] = []
 
   if (Array.isArray(seedData)) {
     for (const doc of seedData) {
-      const record = asRecord(doc);
-      documents.push(normalizeDocument(
-        typeof record.collection === "string" ? record.collection : "imported",
-        record.data ? record : { data: record },
-      ));
+      const record = asRecord(doc)
+      documents.push(
+        normalizeDocument(
+          typeof record.collection === 'string' ? record.collection : 'imported',
+          record.data ? record : { data: record },
+        ),
+      )
     }
-    return { documents, globals };
+    return { documents, globals }
   }
 
-  const root = asRecord(seedData);
+  const root = asRecord(seedData)
 
-  const globalEntries = asRecord(root.globals);
+  const globalEntries = asRecord(root.globals)
   for (const [slug, value] of Object.entries(globalEntries)) {
-    globals.push({ slug, data: asRecord(value) });
+    globals.push({ slug, data: asRecord(value) })
   }
 
-  const collections = root.collections ? asRecord(root.collections) : root;
+  const collections = root.collections ? asRecord(root.collections) : root
   for (const [collection, docs] of Object.entries(collections)) {
-    if (collection === "globals" || collection === "collections") continue;
-    if (!Array.isArray(docs)) continue;
+    if (collection === 'globals' || collection === 'collections') continue
+    if (!Array.isArray(docs)) continue
     for (const doc of docs) {
-      documents.push(normalizeDocument(collection, doc));
+      documents.push(normalizeDocument(collection, doc))
     }
   }
 
-  return { documents, globals };
+  return { documents, globals }
 }
 
 function findConventionSeedFile(): string | null {
   for (const candidate of SEED_FILE_CANDIDATES) {
-    if (existsSync(candidate)) return candidate;
+    if (existsSync(candidate)) return candidate
   }
-  return null;
+  return null
 }
 
 async function loadSeedFile(filePath: string): Promise<unknown> {
-  const extension = path.extname(filePath);
-  if (extension === ".json" || extension === "") {
-    const raw = await readFile(filePath, "utf-8");
-    return JSON.parse(raw);
+  const extension = path.extname(filePath)
+  if (extension === '.json' || extension === '') {
+    const raw = await readFile(filePath, 'utf-8')
+    return JSON.parse(raw)
   }
 
-  const fileUrl = pathToFileURL(path.resolve(filePath)).href;
-  const mod = extension === ".ts"
-    ? await import("tsx/esm/api").then(({ tsImport }) => tsImport(fileUrl, import.meta.url))
-    : await import(fileUrl);
+  const fileUrl = pathToFileURL(path.resolve(filePath)).href
+  const mod =
+    extension === '.ts'
+      ? await import('tsx/esm/api').then(({ tsImport }) => tsImport(fileUrl, import.meta.url))
+      : await import(fileUrl)
 
-  return (mod as { default?: unknown; seed?: unknown }).default
-    ?? (mod as { seed?: unknown }).seed;
+  return (mod as { default?: unknown; seed?: unknown }).default ?? (mod as { seed?: unknown }).seed
 }
 
 async function runSeed(options: SeedOptions): Promise<void> {
-  const conventionFile = !options.demo && !options.file ? findConventionSeedFile() : null;
-  const file = options.file ?? conventionFile ?? undefined;
+  const conventionFile = !options.demo && !options.file ? findConventionSeedFile() : null
+  const file = options.file ?? conventionFile ?? undefined
 
   if (!options.demo && !file) {
-    logger.error("Specify --demo, --file <path>, or add actuate.seed.json in the project root.");
-    process.exit(1);
+    logger.error('Specify --demo, --file <path>, or add actuate.seed.json in the project root.')
+    process.exit(1)
   }
 
-  let seededDb: { db: any; disconnect: () => Promise<void> } | null = null;
+  let seededDb: { db: any; disconnect: () => Promise<void> } | null = null
 
   try {
-    seededDb = await getSeedDatabase();
-    const db = seededDb.db;
+    seededDb = await getSeedDatabase()
+    const db = seededDb.db
 
     if (options.reset) {
-      const yes = await confirm(
-        "This will delete ALL existing documents and versions. Continue?",
-      );
+      const yes = await confirm('This will delete ALL existing documents and versions. Continue?')
       if (!yes) {
-        logger.warn("Seed cancelled.");
-        return;
+        logger.warn('Seed cancelled.')
+        return
       }
 
-      const resetSpinner = ora("Clearing existing data…").start();
-      await db.version.deleteMany({});
+      const resetSpinner = ora('Clearing existing data…').start()
+      await db.version.deleteMany({})
       if (db.mediaUsage?.deleteMany) {
-        await db.mediaUsage.deleteMany({});
+        await db.mediaUsage.deleteMany({})
       }
-      await db.document.deleteMany({});
-      resetSpinner.succeed("Existing data cleared.");
+      await db.document.deleteMany({})
+      resetSpinner.succeed('Existing data cleared.')
     }
 
     if (options.demo) {
-      await seedDemoData(db);
+      await seedDemoData(db)
     }
 
     if (file) {
-      await seedFromFile(db, file);
+      await seedFromFile(db, file)
     }
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    logger.error(`Seed failed: ${message}`);
-    process.exit(1);
+    const message = err instanceof Error ? err.message : String(err)
+    logger.error(`Seed failed: ${message}`)
+    process.exit(1)
   } finally {
-    await seededDb?.disconnect();
+    await seededDb?.disconnect()
   }
 }
 
 async function getSeedDatabase(): Promise<{ db: any; disconnect: () => Promise<void> }> {
-  const { getDB, initDB, isDBInitialized } = await import("@actuate-media/cms-core");
+  const { getDB, initDB, isDBInitialized } = await import('@actuate-media/cms-core')
 
   if (isDBInitialized()) {
-    return { db: getDB<any>(), disconnect: async () => {} };
+    return { db: getDB<any>(), disconnect: async () => {} }
   }
 
-  const db = await createProjectPrismaClient();
-  initDB(db);
+  const db = await createProjectPrismaClient()
+  initDB(db)
   return {
     db,
     disconnect: async () => {
-      if (typeof db.$disconnect === "function") {
-        await db.$disconnect();
+      if (typeof db.$disconnect === 'function') {
+        await db.$disconnect()
       }
     },
-  };
+  }
 }
 
 async function createProjectPrismaClient(): Promise<any> {
   if (!process.env.DATABASE_URL) {
-    throw new Error("DATABASE_URL is required to run seed/populate.");
+    throw new Error('DATABASE_URL is required to run seed/populate.')
   }
 
-  const requireFromProject = createRequire(path.join(process.cwd(), "package.json"));
-  const generatedClient = path.resolve("generated", "prisma", "client.ts");
+  const requireFromProject = createRequire(path.join(process.cwd(), 'package.json'))
+  const generatedClient = path.resolve('generated', 'prisma', 'client.ts')
 
   if (existsSync(generatedClient)) {
     const [{ tsImport }, adapterModule, pgModule] = await Promise.all([
-      import("tsx/esm/api"),
-      import(pathToFileURL(requireFromProject.resolve("@prisma/adapter-pg")).href),
-      import(pathToFileURL(requireFromProject.resolve("pg")).href),
-    ]);
-    const { PrismaClient } = await tsImport(pathToFileURL(generatedClient).href, import.meta.url) as {
-      PrismaClient: new (options?: unknown) => any;
-    };
-    const { PrismaPg } = adapterModule as { PrismaPg: new (pool: unknown) => unknown };
-    const pg = (pgModule as { default?: typeof pgModule }).default ?? pgModule;
-    const pool = new (pg as any).Pool({ connectionString: process.env.DATABASE_URL });
-    const adapter = new PrismaPg(pool);
-    return new PrismaClient({ adapter } as any);
+      import('tsx/esm/api'),
+      import(pathToFileURL(requireFromProject.resolve('@prisma/adapter-pg')).href),
+      import(pathToFileURL(requireFromProject.resolve('pg')).href),
+    ])
+    const { PrismaClient } = (await tsImport(
+      pathToFileURL(generatedClient).href,
+      import.meta.url,
+    )) as {
+      PrismaClient: new (options?: unknown) => any
+    }
+    const { PrismaPg } = adapterModule as { PrismaPg: new (pool: unknown) => unknown }
+    const pg = (pgModule as { default?: typeof pgModule }).default ?? pgModule
+    const pool = new (pg as any).Pool({ connectionString: process.env.DATABASE_URL })
+    const adapter = new PrismaPg(pool)
+    return new PrismaClient({ adapter } as any)
   }
 
-  const clientModule = await import(pathToFileURL(requireFromProject.resolve("@prisma/client")).href) as {
-    PrismaClient: new () => any;
-  };
-  return new clientModule.PrismaClient();
+  const clientModule = (await import(
+    pathToFileURL(requireFromProject.resolve('@prisma/client')).href
+  )) as {
+    PrismaClient: new () => any
+  }
+  return new clientModule.PrismaClient()
 }
 
 export async function ensureSeedAdmin(db: any): Promise<{ id: string }> {
-  const existing = await db.user.findFirst({ where: { role: "ADMIN" } });
-  if (existing) return existing;
+  const existing = await db.user.findFirst({ where: { role: 'ADMIN' } })
+  if (existing) return existing
 
-  const email = process.env.CMS_ADMIN_EMAIL;
-  const password = process.env.CMS_ADMIN_PASSWORD;
-  const name = process.env.CMS_ADMIN_NAME ?? "Admin";
+  const email = process.env.CMS_ADMIN_EMAIL
+  const password = process.env.CMS_ADMIN_PASSWORD
+  const name = process.env.CMS_ADMIN_NAME ?? 'Admin'
 
   if (!email || !password) {
     throw new Error(
-      "No admin user exists. Set CMS_ADMIN_EMAIL and CMS_ADMIN_PASSWORD before running seed, or complete the setup wizard first.",
-    );
+      'No admin user exists. Set CMS_ADMIN_EMAIL and CMS_ADMIN_PASSWORD before running seed, or complete the setup wizard first.',
+    )
   }
 
-  const { createInitialAdmin } = await import("@actuate-media/cms-core");
-  const result = await createInitialAdmin(db, { email, password, name });
+  const { createInitialAdmin } = await import('@actuate-media/cms-core')
+  const result = await createInitialAdmin(db, { email, password, name })
   if (!result.success || !result.userId) {
-    throw new Error(result.error ?? "Failed to create initial admin user");
+    throw new Error(result.error ?? 'Failed to create initial admin user')
   }
 
-  return { id: result.userId };
+  return { id: result.userId }
 }
 
 function sanitizeSeedData(value: unknown, sanitizeHtml: (html: string) => string): unknown {
   if (Array.isArray(value)) {
-    return value.map((item) => sanitizeSeedData(item, sanitizeHtml));
+    return value.map((item) => sanitizeSeedData(item, sanitizeHtml))
   }
-  if (value && typeof value === "object") {
+  if (value && typeof value === 'object') {
     return Object.fromEntries(
       Object.entries(value as Record<string, unknown>).map(([key, item]) => [
         key,
         sanitizeSeedData(item, sanitizeHtml),
       ]),
-    );
+    )
   }
-  if (typeof value === "string" && /<[a-z][\s\S]*>/i.test(value)) {
-    return sanitizeHtml(value);
+  if (typeof value === 'string' && /<[a-z][\s\S]*>/i.test(value)) {
+    return sanitizeHtml(value)
   }
-  return value;
+  return value
 }
 
 export async function createSeedDocument(
@@ -416,78 +410,78 @@ export async function createSeedDocument(
   userId: string,
   doc: NormalizedSeedDocument,
 ): Promise<void> {
-  const { extractPlainText, hashContent, sanitizeHtml } = await import("@actuate-media/cms-core");
-  const data = sanitizeSeedData(doc.data, sanitizeHtml) as Record<string, unknown>;
-  const serialized = JSON.stringify(data);
-  const plainText = extractPlainText(serialized);
-  const contentHash = await hashContent(serialized);
+  const { extractPlainText, hashContent, sanitizeHtml } = await import('@actuate-media/cms-core')
+  const data = sanitizeSeedData(doc.data, sanitizeHtml) as Record<string, unknown>
+  const serialized = JSON.stringify(data)
+  const plainText = extractPlainText(serialized)
+  const contentHash = await hashContent(serialized)
 
   await db.$transaction(async (tx: any) => {
     const created = await tx.document.create({
       data: {
         collection: doc.collection,
-        title: typeof data.title === "string" ? data.title : null,
-        slug: typeof data.slug === "string" ? data.slug : null,
+        title: typeof data.title === 'string' ? data.title : null,
+        slug: typeof data.slug === 'string' ? data.slug : null,
         data,
         status: doc.status,
-        publishedAt: doc.status === "PUBLISHED" ? new Date() : null,
+        publishedAt: doc.status === 'PUBLISHED' ? new Date() : null,
         createdById: userId,
         updatedById: userId,
         plainText,
         contentHash,
       },
-    });
+    })
 
     await tx.version.create({
       data: {
         documentId: created.id,
         data,
         changedById: userId,
-        changeType: "CREATE",
+        changeType: 'CREATE',
       },
-    });
-  });
+    })
+  })
 }
 
 async function seedDemoData(db: any): Promise<void> {
-  const spinner = ora("Seeding demo data…").start();
+  const spinner = ora('Seeding demo data…').start()
 
-  const adminUser = await ensureSeedAdmin(db);
-  const userId = adminUser.id;
+  const adminUser = await ensureSeedAdmin(db)
+  const userId = adminUser.id
 
-  let pagesCreated = 0;
+  let pagesCreated = 0
   for (const page of DEMO_PAGES) {
     await createSeedDocument(db, userId, {
-      collection: "pages",
+      collection: 'pages',
       data: page,
-      status: "PUBLISHED",
-    });
-    pagesCreated++;
+      status: 'PUBLISHED',
+    })
+    pagesCreated++
   }
 
-  let postsCreated = 0;
+  let postsCreated = 0
   for (const post of DEMO_POSTS) {
     await createSeedDocument(db, userId, {
-      collection: "posts",
+      collection: 'posts',
       data: post,
       status: post.status,
-    });
-    postsCreated++;
+    })
+    postsCreated++
   }
 
-  let formsCreated = 0;
+  let formsCreated = 0
   for (const form of DEMO_FORMS) {
     await createSeedDocument(db, userId, {
-      collection: "forms",
+      collection: 'forms',
       data: form,
-      status: "PUBLISHED",
-    });
-    formsCreated++;
+      status: 'PUBLISHED',
+    })
+    formsCreated++
   }
 
-  let usersCreated = 0;
+  let usersCreated = 0
   for (const user of DEMO_USERS) {
-    const exists = await db.user.findFirst({ where: { email: user.email } });
+    const exists = await db.user.findFirst({ where: { email: user.email } })
     if (!exists) {
       await db.user.create({
         data: {
@@ -498,74 +492,74 @@ async function seedDemoData(db: any): Promise<void> {
           isApproved: true,
           emailVerified: true,
         },
-      });
-      usersCreated++;
+      })
+      usersCreated++
     }
   }
 
-  spinner.succeed("Demo data seeded successfully.");
-  logger.info(`  Pages:  ${pagesCreated}`);
-  logger.info(`  Posts:  ${postsCreated}`);
-  logger.info(`  Forms:  ${formsCreated}`);
-  logger.info(`  Users:  ${usersCreated} (+ existing admin)`);
+  spinner.succeed('Demo data seeded successfully.')
+  logger.info(`  Pages:  ${pagesCreated}`)
+  logger.info(`  Posts:  ${postsCreated}`)
+  logger.info(`  Forms:  ${formsCreated}`)
+  logger.info(`  Users:  ${usersCreated} (+ existing admin)`)
 }
 
 async function seedFromFile(db: any, filePath: string): Promise<void> {
   if (!existsSync(filePath)) {
-    logger.error(`File not found: ${filePath}`);
-    process.exit(1);
+    logger.error(`File not found: ${filePath}`)
+    process.exit(1)
   }
 
-  const spinner = ora(`Seeding from ${filePath}…`).start();
+  const spinner = ora(`Seeding from ${filePath}…`).start()
 
-  let seedData: any;
+  let seedData: any
   try {
-    seedData = await loadSeedFile(filePath);
+    seedData = await loadSeedFile(filePath)
   } catch {
-    spinner.fail("Invalid seed file.");
-    process.exit(1);
+    spinner.fail('Invalid seed file.')
+    process.exit(1)
   }
 
-  if (!Array.isArray(seedData) && typeof seedData !== "object") {
-    spinner.fail("Seed file must contain a JSON array or an object with collection keys.");
-    process.exit(1);
+  if (!Array.isArray(seedData) && typeof seedData !== 'object') {
+    spinner.fail('Seed file must contain a JSON array or an object with collection keys.')
+    process.exit(1)
   }
 
-  const adminUser = await ensureSeedAdmin(db);
-  const userId = adminUser.id;
+  const adminUser = await ensureSeedAdmin(db)
+  const userId = adminUser.id
 
-  const normalized = normalizeSeedPayload(seedData);
-  const { updateGlobal } = await import("@actuate-media/cms-core");
-  const ctx = { userId, role: "ADMIN", db };
+  const normalized = normalizeSeedPayload(seedData)
+  const { updateGlobal } = await import('@actuate-media/cms-core')
+  const ctx = { userId, role: 'ADMIN', db }
 
-  let documentCount = 0;
+  let documentCount = 0
   for (const doc of normalized.documents) {
-    await createSeedDocument(db, userId, doc);
-    documentCount++;
+    await createSeedDocument(db, userId, doc)
+    documentCount++
   }
 
-  let globalCount = 0;
+  let globalCount = 0
   for (const global of normalized.globals) {
-    await updateGlobal(global.slug, global.data, ctx);
-    globalCount++;
+    await updateGlobal(global.slug, global.data, ctx)
+    globalCount++
   }
 
-  spinner.succeed(`Seeded ${documentCount} documents and ${globalCount} globals from ${filePath}.`);
+  spinner.succeed(`Seeded ${documentCount} documents and ${globalCount} globals from ${filePath}.`)
 }
 
 export function registerSeedCommand(program: Command): void {
   program
-    .command("seed")
-    .description("Seed the database with demo or custom data")
-    .option("--demo", "Seed demo content (pages, posts, forms, users)")
-    .option("--file <path>", "Seed from a JSON, JavaScript, or TypeScript file")
-    .option("--reset", "Clear existing data before seeding")
-    .action(runSeed);
+    .command('seed')
+    .description('Seed the database with demo or custom data')
+    .option('--demo', 'Seed demo content (pages, posts, forms, users)')
+    .option('--file <path>', 'Seed from a JSON, JavaScript, or TypeScript file')
+    .option('--reset', 'Clear existing data before seeding')
+    .action(runSeed)
 
   program
-    .command("populate")
-    .description("Populate the database from actuate.seed.json or a custom seed file")
-    .option("--file <path>", "Seed from a JSON, JavaScript, or TypeScript file")
-    .option("--reset", "Clear existing data before seeding")
-    .action(runSeed);
+    .command('populate')
+    .description('Populate the database from actuate.seed.json or a custom seed file')
+    .option('--file <path>', 'Seed from a JSON, JavaScript, or TypeScript file')
+    .option('--reset', 'Clear existing data before seeding')
+    .action(runSeed)
 }