opacacms 0.1.0

package/dist/chunk-5gvbp2qa.js

@@ -0,0 +1,167 @@
+import"./chunk-8sqjbsgt.js";
+
+// src/cli/r2-mock.ts
+import { Database } from "bun:sqlite";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+function createR2Mock(dbPath) {
+  let sqlite;
+  let blobsDir;
+  let finalDbPath;
+  const wranglerR2Dir = path.resolve(process.cwd(), ".wrangler/state/v3/r2/miniflare-R2BucketObject");
+  if (!dbPath && fs.existsSync(wranglerR2Dir)) {
+    const files = fs.readdirSync(wranglerR2Dir);
+    const sqliteFile = files.find((f) => f.endsWith(".sqlite"));
+    if (sqliteFile) {
+      finalDbPath = path.join(wranglerR2Dir, sqliteFile);
+      console.log(`[OpacaCMS] Using Wrangler R2 local state: ${sqliteFile}`);
+    }
+  }
+  if (!finalDbPath) {
+    const inputPath = dbPath || ".opaca/local-r2/mock-bucket.sqlite";
+    const absolutePath = path.isAbsolute(inputPath) ? inputPath : path.resolve(process.cwd(), inputPath);
+    if (fs.existsSync(absolutePath) && fs.statSync(absolutePath).isDirectory()) {
+      finalDbPath = path.join(absolutePath, "mock-bucket.sqlite");
+    } else if (!absolutePath.endsWith(".sqlite")) {
+      finalDbPath = absolutePath.endsWith("/") ? path.join(absolutePath, "mock-bucket.sqlite") : absolutePath + ".sqlite";
+    } else {
+      finalDbPath = absolutePath;
+    }
+    console.log(`[OpacaCMS] Using local R2 mock: ${path.basename(finalDbPath)}`);
+  }
+  const dir = path.dirname(finalDbPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  try {
+    sqlite = new Database(finalDbPath);
+  } catch (err) {
+    throw new Error(`Failed to open R2 mock database at ${finalDbPath}: ${err.message}`);
+  }
+  blobsDir = finalDbPath.replace(".sqlite", ".blobs");
+  if (!fs.existsSync(blobsDir)) {
+    fs.mkdirSync(dir, { recursive: true });
+    fs.mkdirSync(blobsDir, { recursive: true });
+  }
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS _mf_objects (
+      key TEXT PRIMARY KEY,
+      blob_id TEXT,
+      version TEXT,
+      size INTEGER,
+      etag TEXT,
+      uploaded INTEGER,
+      checksums TEXT,
+      http_metadata TEXT,
+      custom_metadata TEXT
+    )
+  `);
+  const getBlobPath = (blobId) => path.join(blobsDir, blobId);
+  return {
+    async put(key, value, options) {
+      const blobId = crypto.randomUUID();
+      const filePath = getBlobPath(blobId);
+      const buffer = value instanceof Uint8Array ? value : value instanceof ArrayBuffer ? new Uint8Array(value) : typeof value === "string" || value instanceof Buffer ? Buffer.from(value) : new Uint8Array(await value.arrayBuffer());
+      fs.writeFileSync(filePath, buffer);
+      const etag = crypto.createHash("md5").update(buffer).digest("hex");
+      const uploaded = Date.now();
+      const size = buffer.length;
+      const httpMetadataObj = {};
+      if (options?.httpMetadata?.contentType) {
+        httpMetadataObj.contentType = options.httpMetadata.contentType;
+      }
+      const customMetadataObj = { ...options?.customMetadata };
+      if (options?.customMetadata?.sourceUrl) {
+        customMetadataObj.sourceUrl = options.customMetadata.sourceUrl;
+      }
+      const httpMetadata = JSON.stringify(httpMetadataObj);
+      const customMetadata = JSON.stringify(customMetadataObj);
+      sqlite.prepare(`
+        INSERT OR REPLACE INTO _mf_objects 
+        (key, blob_id, version, size, etag, uploaded, checksums, http_metadata, custom_metadata)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(key, blobId, "v1", size, etag, uploaded, "{}", httpMetadata, customMetadata);
+      return {
+        key,
+        size,
+        etag,
+        httpMetadata: options?.httpMetadata || {},
+        customMetadata: options?.customMetadata || {}
+      };
+    },
+    async get(key) {
+      const row = sqlite.prepare("SELECT * FROM _mf_objects WHERE key = ?").get(key);
+      if (!row)
+        return null;
+      const filePath = getBlobPath(row.blob_id);
+      if (!fs.existsSync(filePath))
+        return null;
+      const buffer = fs.readFileSync(filePath);
+      const stream = new ReadableStream({
+        start(controller) {
+          controller.enqueue(new Uint8Array(buffer));
+          controller.close();
+        }
+      });
+      return {
+        key: row.key,
+        size: row.size,
+        etag: row.etag,
+        uploaded: new Date(row.uploaded),
+        httpMetadata: JSON.parse(row.http_metadata || "{}"),
+        customMetadata: JSON.parse(row.custom_metadata || "{}"),
+        body: stream,
+        bodyUsed: false,
+        async arrayBuffer() {
+          return buffer.buffer;
+        },
+        async text() {
+          return buffer.toString();
+        },
+        async json() {
+          return JSON.parse(buffer.toString());
+        }
+      };
+    },
+    async head(key) {
+      const row = sqlite.prepare("SELECT key, size, etag, http_metadata, custom_metadata, uploaded FROM _mf_objects WHERE key = ?").get(key);
+      if (!row)
+        return null;
+      return {
+        key: row.key,
+        size: row.size,
+        etag: row.etag,
+        uploaded: new Date(row.uploaded),
+        httpMetadata: JSON.parse(row.http_metadata || "{}"),
+        customMetadata: JSON.parse(row.custom_metadata || "{}")
+      };
+    },
+    async delete(key) {
+      const row = sqlite.prepare("SELECT blob_id FROM _mf_objects WHERE key = ?").get(key);
+      if (row) {
+        const filePath = getBlobPath(row.blob_id);
+        if (fs.existsSync(filePath))
+          fs.unlinkSync(filePath);
+        sqlite.prepare("DELETE FROM _mf_objects WHERE key = ?").run(key);
+      }
+    },
+    async list() {
+      const rows = sqlite.prepare("SELECT * FROM _mf_objects").all();
+      return {
+        objects: rows.map((row) => ({
+          key: row.key,
+          size: row.size,
+          etag: row.etag,
+          uploaded: new Date(row.uploaded),
+          httpMetadata: JSON.parse(row.http_metadata || "{}"),
+          customMetadata: JSON.parse(row.custom_metadata || "{}")
+        })),
+        truncated: false
+      };
+    }
+  };
+}
+export {
+  createR2Mock
+};

package/dist/chunk-62ev8gnc.js

@@ -0,0 +1,41 @@
+// src/utils/logger.ts
+var RESET = "\x1B[0m";
+var BLUE = "\x1B[34m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
+var GRAY = "\x1B[90m";
+var PREFIX = `${BLUE}[OpacaCMS]${RESET}`;
+var logger = {
+  info: (message, ...args) => {
+    console.log(`${PREFIX} ${message}`, ...args);
+  },
+  success: (message, ...args) => {
+    console.log(`${PREFIX} ${GREEN}${message}${RESET}`, ...args);
+  },
+  debug: (message, ...args) => {
+    console.log(`${PREFIX} ${GRAY}${message}${RESET}`, ...args);
+  },
+  warn: (message, ...args) => {
+    console.warn(`${PREFIX} ${YELLOW}Warning: ${message}${RESET}`, ...args);
+  },
+  error: (message, ...args) => {
+    console.error(`${PREFIX} ${RED}Error: ${message}${RESET}`, ...args);
+  },
+  format: (color, msg) => {
+    switch (color) {
+      case "green":
+        return `${GREEN}${msg}${RESET}`;
+      case "red":
+        return `${RED}${msg}${RESET}`;
+      case "yellow":
+        return `${YELLOW}${msg}${RESET}`;
+      case "gray":
+        return `${GRAY}${msg}${RESET}`;
+      default:
+        return msg;
+    }
+  }
+};
+
+export { logger };

package/dist/chunk-6dhs73zq.js

@@ -0,0 +1,126 @@
+import {
+  logger
+} from "./chunk-62ev8gnc.js";
+import {
+  __require
+} from "./chunk-8sqjbsgt.js";
+
+// src/cli/commands/migrate-commands.ts
+import fs from "node:fs";
+import { relative, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+async function migrateCreateCommand(opaca, migrationName = "migration", outDir) {
+  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("./chunk-kwp83w8b.js");
+  const { getSystemCollections } = await import("./chunk-v521d72w.js");
+  let dialect = "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(`\uD83D\uDE80 Migration created successfully at ${relative(process.cwd(), filePath)}`);
+}
+async function migrateRunCommand(db) {
+  logger.info("\uD83C\uDFAC Running migrations...");
+  if (db.runMigrations) {
+    await db.connect();
+    try {
+      await db.runMigrations();
+      logger.success("✅ Migrations applied successfully!");
+    } catch (error) {
+      logger.error(`❌ Failed to run migrations: ${error.message}`);
+      throw error;
+    } finally {}
+  } else {
+    throw new Error(`Adapter ${db.name} does not support running migrations.`);
+  }
+}
+async function migrateStatusCommand(opaca) {
+  logger.info("\uD83D\uDCCA 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 = [];
+  try {
+    await db.connect();
+    const rows = await db.unsafe("SELECT name FROM kysely_migration").catch(() => []);
+    appliedMigrations = rows.map((r) => r.name);
+  } catch (e) {} finally {}
+  console.log(`
+Found ${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(`
+\uD83D\uDCA1 You have ${pending.length} pending migrations. Run 'opacacms migrate' to apply them.`);
+  } else {
+    console.log(`
+✨ All migrations are up to date.`);
+  }
+}
+async function migrateD1Command(migrationDir, isRemote, binding = "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 ? "\uD83C\uDF0A REMOTE (Cloudflare D1)" : "\uD83D\uDCBB LOCAL (SQLite)"}...`);
+  for (const migration of migrations) {
+    const filePath = resolve(fullMigrationDir, migration);
+    console.log(`
+[OpacaCMS] \uD83D\uDCE6 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(`
+[OpacaCMS] ✨ Database migration process completed!`);
+}
+export {
+  migrateStatusCommand,
+  migrateRunCommand,
+  migrateD1Command,
+  migrateCreateCommand
+};