opacacms 0.1.1 → 0.1.2

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

@@ -1,160 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,183 +0,0 @@
-#!/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);
-  });
-}