opacacms 0.1.0

package/src/cli/commands/migrate-commands.ts

@@ -0,0 +1,160 @@
+import fs from "node:fs";
+import { relative, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+import { logger } from "../../utils/logger.js";
+import type { DatabaseAdapter, OpacaConfig } from "../../types";
+
+export async function migrateCreateCommand(
+  opaca: OpacaConfig,
+  migrationName: string = "migration",
+  outDir?: string,
+) {
+  const db = opaca.db;
+  const migrationDir = outDir || db.migrationDir || "./migrations";
+  const fullMigrationDir = resolve(process.cwd(), migrationDir);
+
+  if (!fs.existsSync(fullMigrationDir)) {
+    fs.mkdirSync(fullMigrationDir, { recursive: true });
+  }
+
+  const timestamp = new Date().toISOString().replace(/[-:T]/g, "").split(".")[0];
+  const { generateMigrationCode, generateSQLCode } = await import(
+    "../../db/kysely/migration-generator.js"
+  );
+  const { getSystemCollections } = await import("../../db/system-schema.js");
+
+  let dialect: "sqlite" | "postgres" | "d1" = "sqlite";
+  if (db.name === "postgres") dialect = "postgres";
+  if (db.name === "d1") dialect = "d1";
+
+  const isD1 = dialect === "d1";
+  const fileName = `${timestamp}_${migrationName}.${isD1 ? "sql" : "ts"}`;
+  const filePath = resolve(fullMigrationDir, fileName);
+
+  const allCollections = [...getSystemCollections(), ...(opaca.collections || [])];
+
+  const template = isD1
+    ? generateSQLCode(allCollections, opaca.globals || [])
+    : generateMigrationCode(allCollections, opaca.globals || [], dialect);
+
+  fs.writeFileSync(filePath, template);
+  logger.success(`🚀 Migration created successfully at ${relative(process.cwd(), filePath)}`);
+}
+
+export async function migrateRunCommand(db: DatabaseAdapter) {
+  logger.info("🎬 Running migrations...");
+  if (db.runMigrations) {
+    await db.connect();
+    try {
+      await db.runMigrations();
+      logger.success("✅ Migrations applied successfully!");
+    } catch (error: any) {
+      logger.error(`❌ Failed to run migrations: ${error.message}`);
+      throw error;
+    } finally {
+      // We don't disconnect here because in CLI the process will exit,
+      // and in tests we might want to reuse the same adapter instance.
+    }
+  } else {
+    throw new Error(`Adapter ${db.name} does not support running migrations.`);
+  }
+}
+
+export async function migrateStatusCommand(opaca: OpacaConfig) {
+  logger.info("📊 Checking migration status...");
+  const db = opaca.db;
+  const migrationDir = db.migrationDir || "./migrations";
+  const fullMigrationDir = resolve(process.cwd(), migrationDir);
+
+  if (!fs.existsSync(fullMigrationDir)) {
+    logger.info("No migrations directory found.");
+    return;
+  }
+
+  const migrationFiles = fs
+    .readdirSync(fullMigrationDir)
+    .filter((f) => f.endsWith(".ts") || f.endsWith(".sql"))
+    .sort();
+
+  let appliedMigrations: string[] = [];
+  try {
+    await db.connect();
+    // Try both kysely_migration (default) and _opaca_migrations if we ever change it
+    const rows = (await db.unsafe("SELECT name FROM kysely_migration").catch(() => [])) as any[];
+    appliedMigrations = rows.map((r) => r.name);
+  } catch (e) {
+    // Database or table might not exist yet
+  } finally {
+    // Keep connection alive for potential reuse in tests
+  }
+
+  console.log(`\nFound ${migrationFiles.length} migration files in ${migrationDir}:`);
+  for (const file of migrationFiles) {
+    const name = file.replace(/\.(ts|sql)$/, "");
+    const isApplied = appliedMigrations.includes(name);
+    console.log(`  ${isApplied ? "✅ [Applied]  " : "❌ [Pending]  "} ${file}`);
+  }
+
+  const pending = migrationFiles.filter((f) => !appliedMigrations.includes(f.replace(/\.(ts|sql)$/, "")));
+  if (pending.length > 0) {
+    console.log(`\n💡 You have ${pending.length} pending migrations. Run 'opacacms migrate' to apply them.`);
+  } else {
+    console.log("\n✨ All migrations are up to date.");
+  }
+}
+
+export async function migrateD1Command(
+  migrationDir: string,
+  isRemote: boolean,
+  binding: string = "DB",
+) {
+  const fullMigrationDir = resolve(process.cwd(), migrationDir);
+
+  if (!fs.existsSync(fullMigrationDir)) {
+    throw new Error(`[OpacaCMS] Migration directory not found: ${fullMigrationDir}`);
+  }
+
+  const migrations = fs
+    .readdirSync(fullMigrationDir)
+    .filter((file) => file.endsWith(".sql"))
+    .sort();
+
+  if (migrations.length === 0) {
+    console.log(`[OpacaCMS] No SQL migrations found in ${fullMigrationDir}`);
+    return;
+  }
+
+  console.log(
+    `[OpacaCMS] Found ${migrations.length} migrations. Applying to ${isRemote ? "🌊 REMOTE (Cloudflare D1)" : "💻 LOCAL (SQLite)"}...`,
+  );
+
+  for (const migration of migrations) {
+    const filePath = resolve(fullMigrationDir, migration);
+    console.log(`\n[OpacaCMS] 📦 Applying: ${migration}...`);
+
+    const wranglerArgs = [
+      "wrangler",
+      "d1",
+      "execute",
+      binding,
+      "--file",
+      filePath,
+      isRemote ? "--remote" : "--local",
+      "--yes",
+    ];
+
+    const result = spawnSync("bunx", wranglerArgs, {
+      stdio: "inherit",
+      shell: true,
+      cwd: process.cwd(),
+    });
+
+    if (result.status !== 0) {
+      console.error(`[OpacaCMS] ❌ Failed to apply migration: ${migration}`);
+    } else {
+      console.log(`[OpacaCMS] ✅ Success: ${migration}`);
+    }
+  }
+
+  console.log("\n[OpacaCMS] ✨ Database migration process completed!");
+}

package/src/cli/commands/seed-command.ts

@@ -0,0 +1,11 @@
+import type { OpacaConfig } from "../../types";
+
+export async function seedCommand(opaca: OpacaConfig, count: number, reset: boolean, type: "assets" | "collections") {
+  const { autoSeed } = await import("../seeding.js");
+  try {
+    await autoSeed(opaca, count, reset, type);
+  } catch (error: any) {
+    console.error(`[OpacaCMS] Seeding failed: ${error.message}`);
+    throw error;
+  }
+}

package/src/cli/d1-mock.ts

@@ -0,0 +1,101 @@
+import { Database } from "bun:sqlite";
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * A minimal D1Database mock that wraps bun:sqlite to allow OpacaCMS CLI
+ * to run D1-based configurations locally.
+ *
+ * It prioritizes Wrangler's local state if found.
+ */
+export function createD1Mock(dbPath: string = ".opaca/local-d1.db") {
+  // 1. Try to find Wrangler's local D1 state
+  const wranglerD1Dir = path.resolve(
+    process.cwd(),
+    ".wrangler/state/v3/d1/miniflare-D1DatabaseObject",
+  );
+
+  if (fs.existsSync(wranglerD1Dir)) {
+    const files = fs.readdirSync(wranglerD1Dir);
+    const sqliteFile = files.find((f) => f.endsWith(".sqlite"));
+    if (sqliteFile) {
+      const wranglerPath = path.join(wranglerD1Dir, sqliteFile);
+      try {
+        const sqlite = new Database(wranglerPath);
+        console.log(`[OpacaCMS] Using Wrangler D1 local state: ${sqliteFile}`);
+        return wrapSqlite(sqlite);
+      } catch (e) {
+        console.warn(
+          `[OpacaCMS] Failed to open Wrangler D1 state at ${wranglerPath}. Falling back...`,
+        );
+      }
+    }
+  }
+
+  // 2. Default to provided path (useful for manual testing or CI)
+  const absolutePath = path.isAbsolute(dbPath) ? dbPath : path.resolve(process.cwd(), dbPath);
+  const dir = path.dirname(absolutePath);
+
+  try {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const sqlite = new Database(absolutePath);
+    console.log(`[OpacaCMS] Using local CLI database: ${absolutePath}`);
+    return wrapSqlite(sqlite);
+  } catch (err) {
+    console.warn(
+      `[OpacaCMS] Warning: Could not open database at ${absolutePath}. Using memory database.`,
+    );
+    return wrapSqlite(new Database(":memory:"));
+  }
+}
+
+function wrapSqlite(sqlite: Database) {
+  return {
+    prepare(query: string) {
+      const stmt = sqlite.prepare(query);
+
+      const bridge = {
+        bind(...params: any[]) {
+          (bridge as any)._params = params;
+          return bridge;
+        },
+        async first() {
+          const params = (bridge as any)._params || [];
+          return stmt.get(...params);
+        },
+        async all() {
+          const params = (bridge as any)._params || [];
+          const results = stmt.all(...params);
+          return { results, success: true, meta: {} };
+        },
+        async run() {
+          const params = (bridge as any)._params || [];
+          const result = stmt.run(...params);
+          return {
+            success: true,
+            meta: { changes: result.changes, last_row_id: result.lastInsertRowid },
+          };
+        },
+        async raw() {
+          const params = (bridge as any)._params || [];
+          return stmt.all(...params);
+        },
+      };
+
+      return bridge;
+    },
+    async batch(statements: any[]) {
+      const results = [];
+      for (const stmt of statements) {
+        results.push(await stmt.all());
+      }
+      return results;
+    },
+    async exec(query: string) {
+      sqlite.exec(query);
+      return { count: 0, duration: 0 };
+    },
+  };
+}

package/src/cli/index.test.ts

@@ -0,0 +1,84 @@
+import { afterAll, describe, expect, it } from "bun:test";
+import fs from "fs";
+import { resolve } from "path";
+import { loadConfig } from "./index";
+
+const TMP_DIR = resolve("/tmp/opacacms-cli-test");
+if (!fs.existsSync(TMP_DIR)) fs.mkdirSync(TMP_DIR);
+
+describe("CLI loadConfig", () => {
+  afterAll(() => {
+    fs.rmSync(TMP_DIR, { recursive: true, force: true });
+  });
+
+  const createTempConfig = (name: string, content: string) => {
+    const path = resolve(TMP_DIR, name);
+    fs.writeFileSync(path, content);
+    return path;
+  };
+
+  it("should load a valid config with only default export", async () => {
+    const path = createTempConfig(
+      "valid.ts",
+      `
+      export default {
+        db: { name: 'postgres' },
+        collections: []
+      };
+    `,
+    );
+    const config = await loadConfig(path);
+    expect(config.db.name).toBe("postgres");
+  });
+
+  it("should fail if default export is missing", async () => {
+    const path = createTempConfig(
+      "no-default.ts",
+      `
+      export const config = {
+        db: { name: 'postgres' },
+        collections: []
+      };
+    `,
+    );
+    expect(loadConfig(path)).rejects.toThrow(/must have a 'default' export/);
+  });
+
+  it("should fail if named exports are present", async () => {
+    const path = createTempConfig(
+      "named-exports.ts",
+      `
+      export const foo = "bar";
+      export default {
+        db: { name: 'postgres' },
+        collections: []
+      };
+    `,
+    );
+    expect(loadConfig(path)).rejects.toThrow(/Named exports are not allowed/);
+  });
+
+  it("should fail if default export is a Hono app", async () => {
+    const path = createTempConfig(
+      "hono-app.ts",
+      `
+      export default {
+        fetch: () => {}
+      };
+    `,
+    );
+    expect(loadConfig(path)).rejects.toThrow(/Default export is a Hono application/);
+  });
+
+  it("should fail if no db adapter is found", async () => {
+    const path = createTempConfig(
+      "no-db.ts",
+      `
+      export default {
+        collections: []
+      };
+    `,
+    );
+    expect(loadConfig(path)).rejects.toThrow(/No database adapter found/);
+  });
+});

package/src/cli/index.ts

@@ -0,0 +1,183 @@
+#!/usr/bin/env bun
+import fs from "node:fs";
+import { resolve } from "node:path";
+import { parseArgs } from "node:util";
+import { pathToFileURL } from "node:url";
+
+/**
+ * Loads and validates the OpacaCMS configuration from a file.
+ */
+export async function loadConfig(configPath: string) {
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`Config file not found at ${configPath}`);
+  }
+
+  try {
+    const configUrl = pathToFileURL(configPath).href;
+    const mod = await import(configUrl);
+
+    if (!mod.default) {
+      throw new Error(
+        `The configuration file at ${configPath} must have a 'default' export.`,
+      );
+    }
+
+    const namedExports = Object.keys(mod).filter((k) => k !== "default" && k !== "__esModule");
+    if (namedExports.length > 0) {
+      throw new Error(
+        `Named exports are not allowed in the configuration file. Found: ${namedExports.join(", ")}.`,
+      );
+    }
+
+    let opaca = mod.default;
+
+    if (typeof opaca === "function") {
+      const { createD1Mock } = await import("./d1-mock.js");
+      const { createR2Mock } = await import("./r2-mock.js");
+
+      const mockDb = createD1Mock();
+      const mockBucket = createR2Mock();
+      const mockSecureBucket = createR2Mock(".opaca/local-r2/secure");
+
+      opaca = await opaca(
+        {
+          DB: mockDb,
+          BUCKET: mockBucket,
+          SECURE_BUCKET: mockSecureBucket,
+          OPACA_SECRET: "cli-secret",
+        },
+        { url: "http://localhost:3000" },
+      );
+    }
+
+    if (opaca?.fetch) {
+      throw new Error(
+        "Default export is a Hono application. The CLI requires the configuration object.",
+      );
+    }
+
+    if (!opaca.db) {
+      throw new Error("No database adapter found in config");
+    }
+
+    return opaca;
+  } catch (error: any) {
+    throw error;
+  }
+}
+
+async function main() {
+  const { values, positionals } = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+      config: { type: "string", short: "c" },
+      example: { type: "string", short: "e" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" },
+      out: { type: "string", short: "o" },
+      remote: { type: "boolean" },
+      local: { type: "boolean" },
+      binding: { type: "string", short: "b" },
+      url: { type: "string" },
+      token: { type: "string" },
+      count: { type: "string" },
+      reset: { type: "boolean" },
+    },
+    allowPositionals: true,
+  });
+
+  if (values.help) {
+    console.log("Usage: opacacms <command> [options]");
+    console.log("\nCommands:");
+    console.log("  init [target]       Initialize a new project");
+    console.log("  migrate:create      Generate migrations from your schema");
+    console.log("  migrate             Run pending migrations");
+    console.log("  migrate:status      Show migration status");
+    console.log("  migrate:d1          Apply SQL migrations to D1");
+    console.log("  seed                Seed database with mock data");
+    console.log("  seed:assets         Seed only assets");
+    console.log("  generate:types      Generate TS definitions from instance");
+    process.exit(0);
+  }
+
+  if (values.version) {
+    console.log("OpacaCMS v0.1.0");
+    process.exit(0);
+  }
+
+  const command = positionals[0];
+  if (!command) {
+    console.log("Usage: opacacms <command> [options]. Use --help for more info.");
+    process.exit(1);
+  }
+
+  if (command === "init") {
+    const { initCommand } = await import("./commands/init.js");
+    await initCommand(positionals[1] || "my-opaca-app", values.example as string);
+    return;
+  }
+
+  if (command === "generate:types") {
+    const { generateTypesCommand } = await import("./commands/generate-types.js");
+    await generateTypesCommand(values.url as string, values.token as string, (values.out as string) || "opaca-types.d.ts");
+    return;
+  }
+
+  // Common commands requiring config
+  let configPath = values.config ? resolve(process.cwd(), values.config as string) : "";
+  if (!configPath) {
+    const defaults = ["opacacms.config.ts", "opacacms.config.js", "src/opacacms.config.ts", "src/opacacms.config.js", "index.ts", "index.js"];
+    for (const d of defaults) {
+      if (fs.existsSync(resolve(process.cwd(), d))) {
+        configPath = resolve(process.cwd(), d);
+        break;
+      }
+    }
+  }
+
+  if (!configPath || !fs.existsSync(configPath)) {
+    console.error("Config file not found. Use -c or --config to specify path.");
+    process.exit(1);
+  }
+
+  const opaca = await loadConfig(configPath);
+
+  switch (command) {
+    case "migrate:create": {
+      const { migrateCreateCommand } = await import("./commands/migrate-commands.js");
+      await migrateCreateCommand(opaca, positionals[1], values.out as string);
+      break;
+    }
+    case "migrate": {
+      const { migrateRunCommand } = await import("./commands/migrate-commands.js");
+      await migrateRunCommand(opaca.db);
+      break;
+    }
+    case "migrate:status": {
+      const { migrateStatusCommand } = await import("./commands/migrate-commands.js");
+      await migrateStatusCommand(opaca);
+      break;
+    }
+    case "migrate:d1": {
+      const { migrateD1Command } = await import("./commands/migrate-commands.js");
+      await migrateD1Command((values.out as string) || "./migrations", !!values.remote, (values.binding as string) || "DB");
+      break;
+    }
+    case "seed":
+    case "seed:assets": {
+      const { seedCommand } = await import("./commands/seed-command.js");
+      await seedCommand(opaca, parseInt(values.count as string) || 10, !!values.reset, command === "seed:assets" ? "assets" : "collections");
+      break;
+    }
+    default:
+      console.error(`Unknown command: ${command}`);
+      process.exit(1);
+  }
+}
+
+if (import.meta.main) {
+  main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}