opacacms 0.1.7 → 0.1.8

package/dist/storage/index.js

@@ -1,4 +1,43 @@
-import"../chunk-8sqjbsgt.js";
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/storage/errors.ts
 class StorageError extends Error {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opacacms",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "sideEffects": false,
   "scripts": {
     "build": "bun run ../../scripts/build.ts && tsc --emitDeclarationOnly",

package/dist/chunk-16vgcf3k.js

@@ -1,88 +0,0 @@
-import {
-  notify
-} from "./chunk-j4d50hrx.js";
-
-// src/admin/stores/auth.ts
-import { atom, computed } from "nanostores";
-
-// src/admin/auth-client.ts
-import { createAuthClient } from "better-auth/client";
-import { adminClient } from "better-auth/client/plugins";
-var client = null;
-var currentURL = null;
-var configureAuth = (serverUrl) => {
-  if (!serverUrl || !serverUrl.startsWith("http"))
-    return;
-  const url = serverUrl;
-  const baseURL = url.replace(/\/$/, "") + "/api/auth";
-  if (client && currentURL === baseURL)
-    return;
-  currentURL = baseURL;
-  client = createAuthClient({
-    baseURL,
-    autoRefresh: true,
-    fetchOptions: {
-      credentials: "include"
-    },
-    plugins: [adminClient()]
-  });
-};
-var authClient = new Proxy({}, {
-  get(_, prop) {
-    if (!client) {
-      throw new Error("Auth client not configured. Did you provide a valid serverUrl?");
-    }
-    return client[prop];
-  }
-});
-
-// src/admin/stores/auth.ts
-var $session = atom(null);
-var $isAuthPending = atom(true);
-var $user = computed($session, (session) => session?.user ?? null);
-var $isAuthenticated = computed($session, (session) => !!session);
-async function syncSession() {
-  $isAuthPending.set(true);
-  try {
-    const res = await authClient.getSession();
-    $session.set(res.data);
-  } catch (err) {
-    console.error("[OpacaCMS] Failed to sync session:", err);
-  } finally {
-    $isAuthPending.set(false);
-  }
-}
-async function login(data) {
-  $isAuthPending.set(true);
-  try {
-    const res = await authClient.signIn.email({
-      email: data.email,
-      password: data.password
-    });
-    if (res.error) {
-      throw new Error(res.error.message || "Invalid credentials");
-    }
-    await syncSession();
-    notify("Logged in successfully", "success");
-    return res;
-  } catch (error) {
-    notify(error instanceof Error ? error.message : "Login failed", "error");
-    throw error;
-  } finally {
-    $isAuthPending.set(false);
-  }
-}
-async function logout() {
-  $isAuthPending.set(true);
-  try {
-    await authClient.signOut();
-    $session.set(null);
-    notify("Logged out successfully");
-  } catch {
-    notify("Logout failed", "error");
-  } finally {
-    $isAuthPending.set(false);
-  }
-}
-
-export { configureAuth, authClient, $session, $isAuthPending, $user, $isAuthenticated, syncSession, login, logout };

package/dist/chunk-2yz1nsxs.js

@@ -1,126 +0,0 @@
-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-m09hahe2.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
-};

package/dist/chunk-5gvbp2qa.js

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

@@ -1,41 +0,0 @@
-// 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 };