@actuate-media/cli 0.4.0 → 0.4.2

package/src/commands/export.ts

@@ -1,131 +1,121 @@
-import { Command } from "commander";
-import { writeFile } from "node:fs/promises";
-import ora from "ora";
-import { logger } from "../utils/logger.js";
+import { Command } from 'commander'
+import { writeFile } from 'node:fs/promises'
+import ora from 'ora'
+import { logger } from '../utils/logger.js'
 
 interface ExportOptions {
-  collection?: string;
-  format: string;
-  output?: string;
-  includeDrafts?: boolean;
+  collection?: string
+  format: string
+  output?: string
+  includeDrafts?: boolean
 }
 
 function buildOutputPath(options: ExportOptions): string {
-  if (options.output) return options.output;
-  const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const ext = options.format === "csv" ? "csv" : "json";
-  return `actuate-export-${timestamp}.${ext}`;
+  if (options.output) return options.output
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)
+  const ext = options.format === 'csv' ? 'csv' : 'json'
+  return `actuate-export-${timestamp}.${ext}`
 }
 
 function jsonToCsv(docs: any[]): string {
-  if (docs.length === 0) return "";
+  if (docs.length === 0) return ''
 
-  const keySet = new Set<string>();
+  const keySet = new Set<string>()
   for (const doc of docs) {
-    keySet.add("id");
-    keySet.add("collection");
-    keySet.add("status");
-    keySet.add("createdAt");
-    keySet.add("updatedAt");
-    if (doc.data && typeof doc.data === "object") {
+    keySet.add('id')
+    keySet.add('collection')
+    keySet.add('status')
+    keySet.add('createdAt')
+    keySet.add('updatedAt')
+    if (doc.data && typeof doc.data === 'object') {
       for (const key of Object.keys(doc.data)) {
-        keySet.add(`data.${key}`);
+        keySet.add(`data.${key}`)
       }
     }
   }
-  const headers = Array.from(keySet);
+  const headers = Array.from(keySet)
 
   const escapeCsvValue = (val: unknown): string => {
-    if (val === null || val === undefined) return "";
-    const str = typeof val === "object" ? JSON.stringify(val) : String(val);
-    if (str.includes(",") || str.includes('"') || str.includes("\n")) {
-      return `"${str.replace(/"/g, '""')}"`;
+    if (val === null || val === undefined) return ''
+    const str = typeof val === 'object' ? JSON.stringify(val) : String(val)
+    if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+      return `"${str.replace(/"/g, '""')}"`
     }
-    return str;
-  };
+    return str
+  }
 
   const rows = docs.map((doc) => {
     return headers
       .map((header) => {
-        if (header.startsWith("data.")) {
-          const field = header.slice(5);
-          return escapeCsvValue(doc.data?.[field]);
+        if (header.startsWith('data.')) {
+          const field = header.slice(5)
+          return escapeCsvValue(doc.data?.[field])
         }
-        return escapeCsvValue(doc[header]);
+        return escapeCsvValue(doc[header])
       })
-      .join(",");
-  });
+      .join(',')
+  })
 
-  return [headers.join(","), ...rows].join("\n");
+  return [headers.join(','), ...rows].join('\n')
 }
 
 async function runExport(options: ExportOptions): Promise<void> {
-  const target = options.collection ?? "all collections";
-  const spinner = ora(`Exporting ${target}…`).start();
+  const target = options.collection ?? 'all collections'
+  const spinner = ora(`Exporting ${target}…`).start()
 
   try {
-    const { getDB } = await import("@actuate-media/cms-core");
-    const db = getDB<any>();
+    const { getDB } = await import('@actuate-media/cms-core')
+    const db = getDB<any>()
 
-    const where: any = { deletedAt: null };
+    const where: any = { deletedAt: null }
 
     if (options.collection) {
-      where.collection = options.collection;
+      where.collection = options.collection
     }
 
     if (!options.includeDrafts) {
-      where.status = "PUBLISHED";
+      where.status = 'PUBLISHED'
     }
 
     const docs = await db.document.findMany({
       where,
-      orderBy: { createdAt: "desc" },
-    });
+      orderBy: { createdAt: 'desc' },
+    })
 
     if (docs.length === 0) {
-      spinner.warn("No documents found matching the criteria.");
-      return;
+      spinner.warn('No documents found matching the criteria.')
+      return
     }
 
-    const outputPath = buildOutputPath(options);
-    let content: string;
+    const outputPath = buildOutputPath(options)
+    let content: string
 
-    if (options.format === "csv") {
-      content = jsonToCsv(docs);
+    if (options.format === 'csv') {
+      content = jsonToCsv(docs)
     } else {
-      content = JSON.stringify(docs, null, 2);
+      content = JSON.stringify(docs, null, 2)
     }
 
-    await writeFile(outputPath, content, "utf-8");
-    spinner.succeed(`Exported ${docs.length} documents to ${outputPath}`);
+    await writeFile(outputPath, content, 'utf-8')
+    spinner.succeed(`Exported ${docs.length} documents to ${outputPath}`)
   } catch (err) {
-    spinner.fail("Export failed.");
-    const message = err instanceof Error ? err.message : String(err);
-    logger.error(message);
-    process.exit(1);
+    spinner.fail('Export failed.')
+    const message = err instanceof Error ? err.message : String(err)
+    logger.error(message)
+    process.exit(1)
   }
 }
 
 export function registerExportCommand(program: Command): void {
   program
-    .command("export")
-    .description("Export content to JSON or CSV files")
-    .option(
-      "-c, --collection <slug>",
-      "Export only the specified collection (default: all)",
-    )
-    .option(
-      "-f, --format <type>",
-      "Output format: json or csv",
-      "json",
-    )
-    .option(
-      "-o, --output <path>",
-      "Output file path (default: actuate-export-{timestamp}.{format})",
-    )
+    .command('export')
+    .description('Export content to JSON or CSV files')
+    .option('-c, --collection <slug>', 'Export only the specified collection (default: all)')
+    .option('-f, --format <type>', 'Output format: json or csv', 'json')
     .option(
-      "--include-drafts",
-      "Include draft documents (default: published only)",
+      '-o, --output <path>',
+      'Output file path (default: actuate-export-{timestamp}.{format})',
     )
-    .action(runExport);
+    .option('--include-drafts', 'Include draft documents (default: published only)')
+    .action(runExport)
 }

package/src/commands/generate.ts

@@ -1,28 +1,26 @@
-import { Command } from "commander";
-import ora from "ora";
-import { logger } from "../utils/logger.js";
+import { Command } from 'commander'
+import ora from 'ora'
+import { logger } from '../utils/logger.js'
 
 async function runGenerate(): Promise<void> {
-  const spinner = ora("Generating TypeScript types from schema…").start();
+  const spinner = ora('Generating TypeScript types from schema…').start()
 
   try {
     // Dynamically import the codegen module from cms-core
-    const { runCodegen } = await import("@actuate-media/cms-core/codegen");
-    await runCodegen();
-    spinner.succeed("Type generation complete.");
+    const { runCodegen } = await import('@actuate-media/cms-core/codegen')
+    await runCodegen()
+    spinner.succeed('Type generation complete.')
   } catch (err) {
-    spinner.fail("Type generation failed.");
-    const message = err instanceof Error ? err.message : String(err);
-    logger.error(message);
-    process.exitCode = 1;
+    spinner.fail('Type generation failed.')
+    const message = err instanceof Error ? err.message : String(err)
+    logger.error(message)
+    process.exitCode = 1
   }
 }
 
 export function registerGenerateCommand(program: Command): void {
   program
-    .command("generate")
-    .description(
-      "Run the TypeScript type generator from the cms-core codegen module",
-    )
-    .action(runGenerate);
+    .command('generate')
+    .description('Run the TypeScript type generator from the cms-core codegen module')
+    .action(runGenerate)
 }

package/src/commands/import.ts

@@ -1,243 +1,228 @@
-import { Command } from "commander";
-import { readFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
-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 ora from 'ora'
+import { logger } from '../utils/logger.js'
 
 interface ImportOptions {
-  source: string;
-  format?: string;
-  collection?: string;
-  dryRun?: boolean;
+  source: string
+  format?: string
+  collection?: string
+  dryRun?: boolean
 }
 
 function detectFormat(filePath: string): string {
-  const ext = filePath.split(".").pop()?.toLowerCase();
-  if (ext === "json") return "json";
-  if (ext === "csv") return "csv";
-  if (ext === "xml" || ext === "wxr") return "wordpress";
-  return "json";
+  const ext = filePath.split('.').pop()?.toLowerCase()
+  if (ext === 'json') return 'json'
+  if (ext === 'csv') return 'csv'
+  if (ext === 'xml' || ext === 'wxr') return 'wordpress'
+  return 'json'
 }
 
 function parseCsv(content: string): Record<string, string>[] {
-  const lines = content.split("\n").filter((line) => line.trim());
-  if (lines.length < 2) return [];
+  const lines = content.split('\n').filter((line) => line.trim())
+  if (lines.length < 2) return []
 
   const parseRow = (row: string): string[] => {
-    const values: string[] = [];
-    let current = "";
-    let inQuotes = false;
+    const values: string[] = []
+    let current = ''
+    let inQuotes = false
 
     for (let i = 0; i < row.length; i++) {
-      const char = row[i];
+      const char = row[i]
       if (char === '"') {
         if (inQuotes && row[i + 1] === '"') {
-          current += '"';
-          i++;
+          current += '"'
+          i++
         } else {
-          inQuotes = !inQuotes;
+          inQuotes = !inQuotes
         }
-      } else if (char === "," && !inQuotes) {
-        values.push(current.trim());
-        current = "";
+      } else if (char === ',' && !inQuotes) {
+        values.push(current.trim())
+        current = ''
       } else {
-        current += char;
+        current += char
       }
     }
-    values.push(current.trim());
-    return values;
-  };
+    values.push(current.trim())
+    return values
+  }
 
-  const headers = parseRow(lines[0]!);
+  const headers = parseRow(lines[0]!)
   return lines.slice(1).map((line) => {
-    const values = parseRow(line);
-    const obj: Record<string, string> = {};
+    const values = parseRow(line)
+    const obj: Record<string, string> = {}
     headers.forEach((header, i) => {
-      obj[header] = values[i] ?? "";
-    });
-    return obj;
-  });
+      obj[header] = values[i] ?? ''
+    })
+    return obj
+  })
 }
 
 function parseWordPressXml(content: string): any[] {
-  const items: any[] = [];
-  const itemRegex = /<item>([\s\S]*?)<\/item>/g;
-  let match: RegExpExecArray | null;
+  const items: any[] = []
+  const itemRegex = /<item>([\s\S]*?)<\/item>/g
+  let match: RegExpExecArray | null
 
   while ((match = itemRegex.exec(content)) !== null) {
-    const itemXml = match[1];
+    const itemXml = match[1]
 
     const extract = (tag: string): string => {
-      const tagRegex = new RegExp(`<${tag}><!\\[CDATA\\[([\\s\\S]*?)\\]\\]><\\/${tag}>|<${tag}>([\\s\\S]*?)<\\/${tag}>`);
-      const m = tagRegex.exec(itemXml!);
-      return m?.[1] ?? m?.[2] ?? "";
-    };
+      const tagRegex = new RegExp(
+        `<${tag}><!\\[CDATA\\[([\\s\\S]*?)\\]\\]><\\/${tag}>|<${tag}>([\\s\\S]*?)<\\/${tag}>`,
+      )
+      const m = tagRegex.exec(itemXml!)
+      return m?.[1] ?? m?.[2] ?? ''
+    }
 
-    const title = extract("title");
-    const body = extract("content:encoded");
-    const slug = extract("wp:post_name");
-    const status = extract("wp:status");
-    const postDate = extract("wp:post_date");
-    const postType = extract("wp:post_type");
+    const title = extract('title')
+    const body = extract('content:encoded')
+    const slug = extract('wp:post_name')
+    const status = extract('wp:status')
+    const postDate = extract('wp:post_date')
+    const postType = extract('wp:post_type')
 
-    if (postType && postType !== "post" && postType !== "page") continue;
+    if (postType && postType !== 'post' && postType !== 'page') continue
 
     items.push({
       title,
-      slug: slug || title.toLowerCase().replace(/[^a-z0-9]+/g, "-"),
+      slug: slug || title.toLowerCase().replace(/[^a-z0-9]+/g, '-'),
       content: body,
       wpStatus: status,
       wpPostDate: postDate,
-      collection: postType === "page" ? "pages" : "posts",
-    });
+      collection: postType === 'page' ? 'pages' : 'posts',
+    })
   }
 
-  return items;
+  return items
 }
 
 function printPreviewTable(records: any[], collection: string | undefined): void {
-  console.log("\n  Dry-run preview:\n");
-  console.log(
-    "  " +
-      "Collection".padEnd(16) +
-      "Title / Slug".padEnd(40) +
-      "Status",
-  );
-  console.log("  " + "-".repeat(66));
-
-  const shown = records.slice(0, 20);
+  console.log('\n  Dry-run preview:\n')
+  console.log('  ' + 'Collection'.padEnd(16) + 'Title / Slug'.padEnd(40) + 'Status')
+  console.log('  ' + '-'.repeat(66))
+
+  const shown = records.slice(0, 20)
   for (const rec of shown) {
-    const col = (rec.collection ?? collection ?? "imported").padEnd(16);
-    const label = (rec.title ?? rec.slug ?? "(untitled)").slice(0, 38).padEnd(40);
-    const status = rec.status ?? rec.wpStatus ?? "DRAFT";
-    console.log(`  ${col}${label}${status}`);
+    const col = (rec.collection ?? collection ?? 'imported').padEnd(16)
+    const label = (rec.title ?? rec.slug ?? '(untitled)').slice(0, 38).padEnd(40)
+    const status = rec.status ?? rec.wpStatus ?? 'DRAFT'
+    console.log(`  ${col}${label}${status}`)
   }
 
   if (records.length > 20) {
-    console.log(`  ... and ${records.length - 20} more`);
+    console.log(`  ... and ${records.length - 20} more`)
   }
-  console.log();
+  console.log()
 }
 
 async function runImport(options: ImportOptions): Promise<void> {
-  const { source, collection, dryRun } = options;
+  const { source, collection, dryRun } = options
 
   if (!existsSync(source)) {
-    logger.error(`File not found: ${source}`);
-    process.exit(1);
+    logger.error(`File not found: ${source}`)
+    process.exit(1)
   }
 
-  const format = options.format ?? detectFormat(source);
-  const spinner = ora(`Parsing ${format} file: ${source}…`).start();
+  const format = options.format ?? detectFormat(source)
+  const spinner = ora(`Parsing ${format} file: ${source}…`).start()
 
   try {
-    const raw = await readFile(source, "utf-8");
-    let records: any[];
+    const raw = await readFile(source, 'utf-8')
+    let records: any[]
 
-    if (format === "json") {
-      const parsed = JSON.parse(raw);
+    if (format === 'json') {
+      const parsed = JSON.parse(raw)
       if (!Array.isArray(parsed)) {
-        spinner.fail("JSON file must contain an array of documents.");
-        process.exit(1);
+        spinner.fail('JSON file must contain an array of documents.')
+        process.exit(1)
       }
-      records = parsed;
-    } else if (format === "csv") {
+      records = parsed
+    } else if (format === 'csv') {
       if (!collection) {
-        spinner.fail("The --collection option is required for CSV imports.");
-        process.exit(1);
+        spinner.fail('The --collection option is required for CSV imports.')
+        process.exit(1)
       }
       records = parseCsv(raw).map((row) => ({
         collection,
         ...row,
-      }));
-    } else if (format === "wordpress") {
-      records = parseWordPressXml(raw);
+      }))
+    } else if (format === 'wordpress') {
+      records = parseWordPressXml(raw)
     } else {
-      spinner.fail(`Unsupported format: ${format}`);
-      process.exit(1);
+      spinner.fail(`Unsupported format: ${format}`)
+      process.exit(1)
     }
 
-    spinner.succeed(`Parsed ${records.length} records from ${source}.`);
+    spinner.succeed(`Parsed ${records.length} records from ${source}.`)
 
     if (records.length === 0) {
-      logger.warn("No records found in file.");
-      return;
+      logger.warn('No records found in file.')
+      return
     }
 
     if (dryRun) {
-      printPreviewTable(records, collection);
-      logger.info("Dry run — no data was written.");
-      return;
+      printPreviewTable(records, collection)
+      logger.info('Dry run — no data was written.')
+      return
     }
 
-    const writeSpinner = ora(`Importing ${records.length} records…`).start();
+    const writeSpinner = ora(`Importing ${records.length} records…`).start()
 
-    const { getDB } = await import("@actuate-media/cms-core");
-    const db = getDB<any>();
+    const { getDB } = await import('@actuate-media/cms-core')
+    const db = getDB<any>()
 
-    let adminUser = await db.user.findFirst({ where: { role: "ADMIN" } });
+    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",
+          email: 'admin@actuatecms.dev',
+          name: 'Admin',
+          role: 'ADMIN',
           isActive: true,
           isApproved: true,
           emailVerified: true,
         },
-      });
+      })
     }
-    const userId = adminUser.id;
+    const userId = adminUser.id
 
-    let imported = 0;
+    let imported = 0
     for (const rec of records) {
-      const docCollection = rec.collection ?? collection ?? "imported";
-      const data: any = { ...rec };
-      delete data.collection;
-      delete data.wpStatus;
-      delete data.wpPostDate;
+      const docCollection = rec.collection ?? collection ?? 'imported'
+      const data: any = { ...rec }
+      delete data.collection
+      delete data.wpStatus
+      delete data.wpPostDate
 
       await db.document.create({
         data: {
           collection: docCollection,
           data,
-          status: "DRAFT",
+          status: 'DRAFT',
           createdById: userId,
           updatedById: userId,
         },
-      });
-      imported++;
+      })
+      imported++
     }
 
-    writeSpinner.succeed(`Imported ${imported} documents as DRAFT.`);
+    writeSpinner.succeed(`Imported ${imported} documents as DRAFT.`)
   } catch (err) {
-    spinner.fail("Import failed.");
-    const message = err instanceof Error ? err.message : String(err);
-    logger.error(message);
-    process.exit(1);
+    spinner.fail('Import failed.')
+    const message = err instanceof Error ? err.message : String(err)
+    logger.error(message)
+    process.exit(1)
   }
 }
 
 export function registerImportCommand(program: Command): void {
   program
-    .command("import")
-    .description("Import content from JSON, CSV, or WordPress XML files")
-    .requiredOption(
-      "-s, --source <path>",
-      "Path to the import file",
-    )
-    .option(
-      "-f, --format <type>",
-      "File format: json, csv, or wordpress (default: auto-detect)",
-    )
-    .option(
-      "-c, --collection <slug>",
-      "Target collection (required for csv/wordpress)",
-    )
-    .option(
-      "--dry-run",
-      "Preview import without writing to the database",
-    )
-    .action(runImport);
+    .command('import')
+    .description('Import content from JSON, CSV, or WordPress XML files')
+    .requiredOption('-s, --source <path>', 'Path to the import file')
+    .option('-f, --format <type>', 'File format: json, csv, or wordpress (default: auto-detect)')
+    .option('-c, --collection <slug>', 'Target collection (required for csv/wordpress)')
+    .option('--dry-run', 'Preview import without writing to the database')
+    .action(runImport)
 }

package/src/commands/init.ts

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