@actuate-media/cli 0.2.5 → 0.3.1

package/src/commands/init.ts

@@ -0,0 +1,36 @@
+import { spawn } from 'node:child_process';
+import type { Command } from 'commander';
+import { logger } from '../utils/logger.js';
+
+export function buildCreateActuateArgs(projectName?: string): string[] {
+  const args = ['create', 'actuate-cms@latest'];
+  if (projectName) args.push(projectName);
+  return args;
+}
+
+function npmCommand(): string {
+  return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+
+async function runInit(projectName?: string): Promise<void> {
+  const child = spawn(npmCommand(), buildCreateActuateArgs(projectName), {
+    stdio: 'inherit',
+  });
+
+  const exitCode = await new Promise<number | null>((resolve, reject) => {
+    child.once('error', reject);
+    child.once('exit', resolve);
+  });
+
+  if (exitCode && exitCode !== 0) {
+    logger.error(`Project initialization failed with exit code ${exitCode}.`);
+    process.exit(exitCode);
+  }
+}
+
+export function registerInitCommand(program: Command): void {
+  program
+    .command('init [project-name]')
+    .description('Scaffold a new Actuate CMS project')
+    .action(runInit);
+}

package/src/commands/seed.ts

@@ -1,7 +1,10 @@
 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";
 
@@ -173,15 +176,116 @@ interface SeedOptions {
   reset?: boolean;
 }
 
+export interface NormalizedSeedDocument {
+  collection: string;
+  data: Record<string, unknown>;
+  status: string;
+}
+
+export interface NormalizedSeedGlobal {
+  slug: string;
+  data: Record<string, unknown>;
+}
+
+export interface NormalizedSeedPayload {
+  documents: NormalizedSeedDocument[];
+  globals: NormalizedSeedGlobal[];
+}
+
+const SEED_FILE_CANDIDATES = [
+  "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>
+    : {};
+}
+
+function normalizeDocument(collection: string, doc: unknown): NormalizedSeedDocument {
+  const record = asRecord(doc);
+  return {
+    collection,
+    data: asRecord(record.data ?? record),
+    status: typeof record.status === "string" ? record.status : "DRAFT",
+  };
+}
+
+export function normalizeSeedPayload(seedData: unknown): NormalizedSeedPayload {
+  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 },
+      ));
+    }
+    return { documents, globals };
+  }
+
+  const root = asRecord(seedData);
+
+  const globalEntries = asRecord(root.globals);
+  for (const [slug, value] of Object.entries(globalEntries)) {
+    globals.push({ slug, data: asRecord(value) });
+  }
+
+  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;
+    for (const doc of docs) {
+      documents.push(normalizeDocument(collection, doc));
+    }
+  }
+
+  return { documents, globals };
+}
+
+function findConventionSeedFile(): string | null {
+  for (const candidate of SEED_FILE_CANDIDATES) {
+    if (existsSync(candidate)) return candidate;
+  }
+  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 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;
+}
+
 async function runSeed(options: SeedOptions): Promise<void> {
-  if (!options.demo && !options.file) {
-    logger.error("Specify --demo to seed demo content or --file <path> to seed from a JSON file.");
+  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);
   }
 
+  let seededDb: { db: any; disconnect: () => Promise<void> } | null = null;
+
   try {
-    const { getDB } = await import("@actuate-media/cms-core");
-    const db = getDB<any>();
+    seededDb = await getSeedDatabase();
+    const db = seededDb.db;
 
     if (options.reset) {
       const yes = await confirm(
@@ -203,78 +307,178 @@ async function runSeed(options: SeedOptions): Promise<void> {
       await seedDemoData(db);
     }
 
-    if (options.file) {
-      await seedFromFile(db, options.file);
+    if (file) {
+      await seedFromFile(db, file);
     }
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     logger.error(`Seed failed: ${message}`);
     process.exit(1);
+  } finally {
+    await seededDb?.disconnect();
   }
 }
 
-async function seedDemoData(db: any): Promise<void> {
-  const spinner = ora("Seeding demo data…").start();
+async function getSeedDatabase(): Promise<{ db: any; disconnect: () => Promise<void> }> {
+  const { getDB, initDB, isDBInitialized } = await import("@actuate-media/cms-core");
+
+  if (isDBInitialized()) {
+    return { db: getDB<any>(), disconnect: async () => {} };
+  }
+
+  const db = await createProjectPrismaClient();
+  initDB(db);
+  return {
+    db,
+    disconnect: async () => {
+      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.");
+  }
+
+  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);
+  }
+
+  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 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.",
+    );
+  }
+
+  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");
+  }
+
+  return { id: result.userId };
+}
+
+function sanitizeSeedData(value: unknown, sanitizeHtml: (html: string) => string): unknown {
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeSeedData(item, sanitizeHtml));
+  }
+  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);
+  }
+  return value;
+}
+
+export async function createSeedDocument(
+  db: any,
+  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);
 
-  let adminUser = await db.user.findFirst({ where: { role: "ADMIN" } });
-  if (!adminUser) {
-    adminUser = await db.user.create({
+  await db.$transaction(async (tx: any) => {
+    const created = await tx.document.create({
       data: {
-        email: "admin@actuatecms.dev",
-        name: "Admin",
-        role: "ADMIN",
-        isActive: true,
-        isApproved: true,
-        emailVerified: true,
+        collection: doc.collection,
+        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,
+        createdById: userId,
+        updatedById: userId,
+        plainText,
+        contentHash,
       },
     });
-  }
+
+    await tx.version.create({
+      data: {
+        documentId: created.id,
+        data,
+        changedById: userId,
+        changeType: "CREATE",
+      },
+    });
+  });
+}
+
+async function seedDemoData(db: any): Promise<void> {
+  const spinner = ora("Seeding demo data…").start();
+
+  const adminUser = await ensureSeedAdmin(db);
   const userId = adminUser.id;
 
   let pagesCreated = 0;
   for (const page of DEMO_PAGES) {
-    await db.document.create({
-      data: {
-        collection: "pages",
-        data: page,
-        status: "PUBLISHED",
-        publishedAt: new Date(),
-        createdById: userId,
-        updatedById: userId,
-        plainText: `${page.title} ${page.slug}`,
-      },
+    await createSeedDocument(db, userId, {
+      collection: "pages",
+      data: page,
+      status: "PUBLISHED",
     });
     pagesCreated++;
   }
 
   let postsCreated = 0;
   for (const post of DEMO_POSTS) {
-    await db.document.create({
-      data: {
-        collection: "posts",
-        data: post,
-        status: post.status,
-        publishedAt: post.status === "PUBLISHED" ? new Date() : null,
-        createdById: userId,
-        updatedById: userId,
-        plainText: `${post.title} ${post.excerpt}`,
-      },
+    await createSeedDocument(db, userId, {
+      collection: "posts",
+      data: post,
+      status: post.status,
     });
     postsCreated++;
   }
 
   let formsCreated = 0;
   for (const form of DEMO_FORMS) {
-    await db.document.create({
-      data: {
-        collection: "forms",
-        data: form,
-        status: "PUBLISHED",
-        publishedAt: new Date(),
-        createdById: userId,
-        updatedById: userId,
-        plainText: `${form.title} ${form.slug}`,
-      },
+    await createSeedDocument(db, userId, {
+      collection: "forms",
+      data: form,
+      status: "PUBLISHED",
     });
     formsCreated++;
   }
@@ -312,12 +516,11 @@ async function seedFromFile(db: any, filePath: string): Promise<void> {
 
   const spinner = ora(`Seeding from ${filePath}…`).start();
 
-  const raw = await readFile(filePath, "utf-8");
   let seedData: any;
   try {
-    seedData = JSON.parse(raw);
+    seedData = await loadSeedFile(filePath);
   } catch {
-    spinner.fail("Invalid JSON file.");
+    spinner.fail("Invalid seed file.");
     process.exit(1);
   }
 
@@ -326,55 +529,26 @@ async function seedFromFile(db: any, filePath: string): Promise<void> {
     process.exit(1);
   }
 
-  let adminUser = await db.user.findFirst({ where: { role: "ADMIN" } });
-  if (!adminUser) {
-    adminUser = await db.user.create({
-      data: {
-        email: "admin@actuatecms.dev",
-        name: "Admin",
-        role: "ADMIN",
-        isActive: true,
-        isApproved: true,
-        emailVerified: true,
-      },
-    });
-  }
+  const adminUser = await ensureSeedAdmin(db);
   const userId = adminUser.id;
 
-  let count = 0;
+  const normalized = normalizeSeedPayload(seedData);
+  const { updateGlobal } = await import("@actuate-media/cms-core");
+  const ctx = { userId, role: "ADMIN", db };
 
-  if (Array.isArray(seedData)) {
-    for (const doc of seedData) {
-      await db.document.create({
-        data: {
-          collection: doc.collection ?? "imported",
-          data: doc.data ?? doc,
-          status: doc.status ?? "DRAFT",
-          createdById: userId,
-          updatedById: userId,
-        },
-      });
-      count++;
-    }
-  } else {
-    for (const [collection, docs] of Object.entries(seedData)) {
-      if (!Array.isArray(docs)) continue;
-      for (const doc of docs as any[]) {
-        await db.document.create({
-          data: {
-            collection,
-            data: doc.data ?? doc,
-            status: doc.status ?? "DRAFT",
-            createdById: userId,
-            updatedById: userId,
-          },
-        });
-        count++;
-      }
-    }
+  let documentCount = 0;
+  for (const doc of normalized.documents) {
+    await createSeedDocument(db, userId, doc);
+    documentCount++;
   }
 
-  spinner.succeed(`Seeded ${count} documents from ${filePath}.`);
+  let globalCount = 0;
+  for (const global of normalized.globals) {
+    await updateGlobal(global.slug, global.data, ctx);
+    globalCount++;
+  }
+
+  spinner.succeed(`Seeded ${documentCount} documents and ${globalCount} globals from ${filePath}.`);
 }
 
 export function registerSeedCommand(program: Command): void {
@@ -382,7 +556,14 @@ export function registerSeedCommand(program: Command): void {
     .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 file")
+    .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);
 }

package/src/index.ts

@@ -9,6 +9,7 @@ import { registerUpgradeCommand } from "./commands/upgrade.js";
 import { registerUpdateCheckCommand } from "./commands/update-check.js";
 import { registerDbInitCommand } from "./commands/db-init.js";
 import { registerDbStatusCommand } from "./commands/db-status.js";
+import { registerInitCommand } from "./commands/init.js";
 
 const program = new Command();
 
@@ -26,5 +27,6 @@ registerUpgradeCommand(program);
 registerUpdateCheckCommand(program);
 registerDbInitCommand(program);
 registerDbStatusCommand(program);
+registerInitCommand(program);
 
 program.parse();