opacacms 0.2.1 → 0.3.1

package/dist/{chunk-dykn5hr6.js → chunk-j8js1y0h.js}

@@ -5,13 +5,13 @@ import {
   mapFieldToSQLiteType,
   toSnakeCase
 } from "./chunk-qxt9vge8.js";
+import {
+  logger
+} from "./chunk-jq1drsen.js";
 import {
   getSystemCollections,
   init_system_schema
-} from "./chunk-v9z61v3g.js";
-import {
-  logger
-} from "./chunk-t0zg026p.js";
+} from "./chunk-6qs0g65f.js";
 
 // src/db/kysely/data-mapper.ts
 function toCamelCase(str) {
@@ -192,7 +192,6 @@ function buildKyselyWhere(eb, query) {
 
 // src/db/kysely/schema-builder.ts
 import { sql } from "kysely";
-init_system_schema();
 
 // src/db/kysely/sql-utils.ts
 function assertSafeIdentifier(identifier) {
@@ -206,6 +205,7 @@ function assertSafeIdentifier(identifier) {
 }
 
 // src/db/kysely/schema-builder.ts
+init_system_schema();
 async function pushSchema(db, dialect, collections, globals = [], options = {}) {
   const rawSchemas = [...getSystemCollections(), ...collections, ...globals];
   const allSchemas = [];
@@ -219,20 +219,15 @@ async function pushSchema(db, dialect, collections, globals = [], options = {})
   const { pushDestructive } = options;
   logger.debug(`Starting schema push via Kysely (${dialect})...`);
   const mapType = dialect === "postgres" ? mapFieldToPostgresType : mapFieldToSQLiteType;
-  let existingTables = [];
+  let tablesMetadata = [];
   try {
-    if (dialect === "postgres") {
-      const res = await sql`SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'`.execute(db);
-      existingTables = res.rows.map((r) => r.table_name);
-    } else {
-      const res = await sql`SELECT name FROM sqlite_master WHERE type='table'`.execute(db);
-      existingTables = res.rows.map((r) => r.name);
-    }
-  } catch (_) {
-    logger.warn("Failed to fetch existing tables:");
+    tablesMetadata = await db.introspection.getTables();
+  } catch (e) {
+    logger.warn("Failed to fetch database introspection. Falling back to empty state.", e);
   }
-  logger.info(`Existing tables: ${existingTables.join(", ")}`);
-  const existingTableSet = new Set(existingTables);
+  const existingTableMap = new Map(tablesMetadata.map((t) => [t.name, t]));
+  const existingTables = Array.from(existingTableMap.keys());
+  logger.debug(`Existing tables found: ${existingTables.join(", ")}`);
   const expectedTableNames = new Set;
   for (const collection of allSchemas) {
     const slug = collection.slug;
@@ -242,8 +237,9 @@ async function pushSchema(db, dialect, collections, globals = [], options = {})
     const flattenedFields = flattenFields(collection.fields);
     const hasTimestamps = true;
     const versions = collection.versions;
-    if (!existingTableSet.has(tableName)) {
-      logger.info(`  -> Creating table: ${logger.format("green", `"${tableName}"`)}`);
+    const existingTable = existingTableMap.get(tableName);
+    if (!existingTable) {
+      logger.info(`  ${logger.format("green", "✔")} Creating table: ${logger.bold(`"${tableName}"`)}`);
       let builder = db.schema.createTable(tableName).ifNotExists();
       builder = builder.addColumn("id", "text", (col) => col.primaryKey());
       for (const field of flattenedFields) {
@@ -278,29 +274,8 @@ async function pushSchema(db, dialect, collections, globals = [], options = {})
         builder = builder.addColumn(updatedField, tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`));
       }
       await builder.execute();
-      if (versions) {
-        const versionsTable = `${tableName}_versions`.toLowerCase();
-        assertSafeIdentifier(versionsTable);
-        expectedTableNames.add(versionsTable);
-        if (!existingTableSet.has(versionsTable)) {
-          logger.info(`  -> Creating versions table: ${logger.format("green", `"${versionsTable}"`)}`);
-          await db.schema.createTable(versionsTable).addColumn("id", "text", (col) => col.primaryKey()).addColumn("_parent_id", "text", (col) => col.notNull()).addColumn("_version_data", dialect === "postgres" ? "jsonb" : "text", (col) => col.notNull()).addColumn("_status", "text").addColumn("created_at", dialect === "postgres" ? "timestamp with time zone" : "text", (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`)).execute();
-        }
-      }
     } else {
-      let existingColumns = [];
-      try {
-        if (dialect === "postgres") {
-          const res = await sql`SELECT column_name FROM information_schema.columns WHERE table_schema = 'public' AND table_name = ${tableName}`.execute(db);
-          existingColumns = res.rows.map((r) => r.column_name);
-        } else {
-          const res = await sql`PRAGMA table_info(${sql.id(tableName)})`.execute(db);
-          existingColumns = res.rows.map((r) => r.name);
-        }
-      } catch (e) {
-        logger.warn(`Failed to fetch columns for ${slug}:`, e);
-      }
-      const existingColSet = new Set(existingColumns);
+      const existingColSet = new Set(existingTable.columns.map((c) => c.name));
       for (const field of flattenedFields) {
         if (field.type === "relationship" && "hasMany" in field && field.hasMany)
           continue;
@@ -309,13 +284,13 @@ async function pushSchema(db, dialect, collections, globals = [], options = {})
           continue;
         assertSafeIdentifier(colName);
         if (!existingColSet.has(colName)) {
-          logger.info(`  -> Adding missing column: ${logger.format("green", `${tableName}.${colName}`)}`);
+          logger.info(`  ${logger.format("green", "✔")} Adding column: ${logger.bold(`${tableName}.${colName}`)}`);
           const colType = mapType(field);
           await db.schema.alterTable(tableName).addColumn(colName, colType).execute();
         }
       }
       if (versions?.drafts && !existingColSet.has("_status")) {
-        logger.info(`  -> Adding missing status column to: ${tableName}`);
+        logger.info(`  ${logger.format("green", "✔")} Adding status column to: ${tableName}`);
         await db.schema.alterTable(tableName).addColumn("_status", "text", (col) => col.defaultTo("draft")).execute();
       }
       if (hasTimestamps) {
@@ -333,14 +308,6 @@ async function pushSchema(db, dialect, collections, globals = [], options = {})
           await db.schema.alterTable(tableName).addColumn(updatedField, tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`)).execute();
         }
       }
-      if (versions) {
-        const versionsTable = `${tableName}_versions`.toLowerCase();
-        expectedTableNames.add(versionsTable);
-        if (!existingTableSet.has(versionsTable)) {
-          logger.info(`  -> Creating missing versions table for: ${tableName}`);
-          await db.schema.createTable(versionsTable).addColumn("id", "text", (col) => col.primaryKey()).addColumn("_parent_id", "text", (col) => col.notNull()).addColumn("_version_data", dialect === "postgres" ? "jsonb" : "text", (col) => col.notNull()).addColumn("_status", "text").addColumn("created_at", dialect === "postgres" ? "timestamp with time zone" : "text", (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`)).execute();
-        }
-      }
       if (pushDestructive) {
         const expectedCols = new Set(flattenedFields.filter((f) => !(f.type === "relationship" && f.hasMany)).map((f) => toSnakeCase(f.name)));
         if (hasTimestamps) {
@@ -352,13 +319,14 @@ async function pushSchema(db, dialect, collections, globals = [], options = {})
         if (versions?.drafts)
           expectedCols.add("_status");
         expectedCols.add("id");
-        for (const existingCol of existingColumns) {
-          if (!expectedCols.has(existingCol)) {
-            logger.info(`  -> Dropping stale column: ${logger.format("red", `${tableName}.${existingCol}`)}`);
+        for (const existingCol of existingColSet) {
+          const colName = existingCol;
+          if (!expectedCols.has(colName)) {
+            logger.info(`  -> Dropping stale column: ${logger.format("red", `${tableName}.${colName}`)}`);
             try {
-              await db.schema.alterTable(tableName).dropColumn(existingCol).execute();
+              await db.schema.alterTable(tableName).dropColumn(colName).execute();
             } catch (_) {
-              logger.warn(`Failed to drop column ${existingCol}.`);
+              logger.warn(`Failed to drop column ${colName}.`);
             }
           }
         }
@@ -367,20 +335,18 @@ async function pushSchema(db, dialect, collections, globals = [], options = {})
     const relationalFields = getRelationalFields(collection.fields);
     for (const field of relationalFields) {
       if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
-        const sourceIdType = "text";
         const colName = toSnakeCase(field.name);
         const joinTableName = `${tableName}_${colName}_relations`.toLowerCase();
         assertSafeIdentifier(joinTableName);
         expectedTableNames.add(joinTableName);
-        if (!existingTableSet.has(joinTableName)) {
+        if (!existingTableMap.has(joinTableName)) {
           logger.info(`  -> Creating relation table: ${logger.format("green", `"${joinTableName}"`)}`);
-          await db.schema.createTable(joinTableName).ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("source_id", sourceIdType, (col) => col.notNull()).addColumn("target_id", "text", (col) => col.notNull()).addColumn("order", "integer", (col) => col.defaultTo(0)).execute();
+          await db.schema.createTable(joinTableName).ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("source_id", "text", (col) => col.notNull()).addColumn("target_id", "text", (col) => col.notNull()).addColumn("order", "integer", (col) => col.defaultTo(0)).execute();
         }
       }
     }
     for (const field of relationalFields) {
       if (field.type === "blocks" && field.blocks && Array.isArray(field.blocks)) {
-        const parentIdType = "text";
         for (const block of field.blocks) {
           const blockName = toSnakeCase(field.name);
           const blockSlug = toSnakeCase(block.slug);
@@ -389,9 +355,10 @@ async function pushSchema(db, dialect, collections, globals = [], options = {})
           const blockTableName = `${tableName}_${blockName}_${blockSlug}`.toLowerCase();
           assertSafeIdentifier(blockTableName);
           expectedTableNames.add(blockTableName);
-          if (!existingTableSet.has(blockTableName)) {
+          const existingBlockTable = existingTableMap.get(blockTableName);
+          if (!existingBlockTable) {
             logger.info(`  -> Creating block table: ${logger.format("green", `"${blockTableName}"`)}`);
-            let bBuilder = db.schema.createTable(blockTableName).ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("_parent_id", parentIdType, (col) => col.notNull()).addColumn("_order", "integer", (col) => col.defaultTo(0)).addColumn("block_type", "text", (col) => col.notNull().defaultTo(block.slug));
+            let bBuilder = db.schema.createTable(blockTableName).ifNotExists().addColumn("id", "text", (col) => col.primaryKey()).addColumn("_parent_id", "text", (col) => col.notNull()).addColumn("_order", "integer", (col) => col.defaultTo(0)).addColumn("block_type", "text", (col) => col.notNull().defaultTo(block.slug));
             const blockFlattened = flattenFields(block.fields);
             for (const bField of blockFlattened) {
               const bColName = toSnakeCase(bField.name);
@@ -415,17 +382,7 @@ async function pushSchema(db, dialect, collections, globals = [], options = {})
             bBuilder = bBuilder.addColumn("updated_at", tsType, (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`));
             await bBuilder.execute();
           } else {
-            let existingBCols = [];
-            try {
-              if (dialect === "postgres") {
-                const res = await sql`SELECT column_name FROM information_schema.columns WHERE table_schema = 'public' AND table_name = ${blockTableName}`.execute(db);
-                existingBCols = res.rows.map((r) => r.column_name);
-              } else {
-                const res = await sql`PRAGMA table_info(${sql.id(blockTableName)})`.execute(db);
-                existingBCols = res.rows.map((r) => r.name);
-              }
-            } catch (_) {}
-            const existingBColSet = new Set(existingBCols);
+            const existingBColSet = new Set(existingBlockTable.columns.map((c) => c.name));
             const blockFlattened = flattenFields(block.fields);
             for (const bField of blockFlattened) {
               const bColName = toSnakeCase(bField.name);
@@ -466,7 +423,7 @@ async function pushSchema(db, dialect, collections, globals = [], options = {})
       }
     }
   }
-  logger.success(`Schema push to Kysely (${dialect}) completed.`);
+  logger.info(`${logger.format("green", "✔")} Schema synchronization complete.`);
 }
 
 export { flattenPayload, unflattenRow, buildKyselyWhere, pushSchema };

package/dist/{chunk-t0zg026p.js → chunk-jq1drsen.js}

@@ -1,11 +1,12 @@
 // src/utils/logger.ts
 var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
 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 PREFIX = `${BLUE}${BOLD}[OpacaCMS]${RESET}`;
 var LOG_LEVELS = {
   debug: 0,
   info: 1,
@@ -49,6 +50,16 @@ class OpacaLogger {
       return;
     console.error(`${PREFIX} ${RED}Error: ${message}${RESET}`, ...args);
   }
+  log(message, ...args) {
+    if (this.config.disabled)
+      return;
+    console.log(message, ...args);
+  }
+  bold(msg) {
+    if (this.config.disableColors)
+      return msg;
+    return `${BOLD}${msg}${RESET}`;
+  }
   format(color, msg) {
     if (this.config.disableColors)
       return msg;

package/dist/{chunk-b3kr8w41.js → chunk-m24yqkeq.js}

@@ -1,16 +1,22 @@
+import {
+  exports_compiler,
+  init_compiler
+} from "./chunk-m5ems3hh.js";
+import {
+  OpacaLogger
+} from "./chunk-jq1drsen.js";
 import {
   getSystemCollections,
   init_system_schema
-} from "./chunk-v9z61v3g.js";
+} from "./chunk-6qs0g65f.js";
 import {
-  OpacaLogger
-} from "./chunk-t0zg026p.js";
+  __toCommonJS
+} from "./chunk-6bywt602.js";
 
 // src/auth/index.ts
 import { apiKey } from "@better-auth/api-key";
 import { betterAuth } from "better-auth";
 import { admin, openAPI } from "better-auth/plugins";
-import { CamelCasePlugin } from "kysely";
 
 // src/auth/premissions.ts
 import { createAccessControl } from "better-auth/plugins/access";
@@ -48,10 +54,6 @@ function createPermissions(config) {
 
 // src/auth/index.ts
 async function createAuth(config) {
-  const userAuth = config.auth || {};
-  const trustedOrigins = config.trustedOrigins;
-  const { ac, roles } = createPermissions(config);
-  const rawDb = config.db.raw;
   const env = typeof process !== "undefined" ? process.env : {};
   const baseURL = String(config.serverURL || env.BETTER_AUTH_URL || "").replace(/\/$/, "");
   if (!baseURL) {
@@ -65,20 +67,14 @@ async function createAuth(config) {
   if (typeof process !== "undefined" && !env.BETTER_AUTH_URL) {
     process.env.BETTER_AUTH_URL = authURL;
   }
-  let databaseConfig;
-  const kysely = config.db.db;
-  if (kysely && typeof kysely.selectFrom === "function") {
-    databaseConfig = {
-      db: kysely.withPlugin(new CamelCasePlugin),
-      type: config.db.name === "postgres" ? "pg" : "sqlite"
-    };
-  } else {
-    databaseConfig = {
-      db: rawDb,
-      type: config.db.name === "postgres" ? "pg" : "sqlite"
-    };
-  }
+  const databaseConfig = {
+    db: config.db.db,
+    type: config.db.name === "postgres" ? "pg" : "sqlite"
+  };
   const isSecure = baseURL.startsWith("https");
+  const userAuth = config.auth || {};
+  const { ac, roles } = createPermissions(config);
+  const trustedOrigins = config.trustedOrigins;
   const plugins = [
     admin({
       ac,
@@ -177,6 +173,9 @@ async function createAuth(config) {
           return msg.replace(/\[better-auth\]\s*/g, "").replace(/BETTER_AUTH_SECRET/g, "OPACA_SECRET").replace(/`npx auth secret`/g, "`openssl rand -base64 32`").replace(/npx auth secret/g, "openssl rand -base64 32").replace(/^Warning:\s*/i, "");
         };
         const branded = rebrand(message);
+        if (level === "error" && (branded.toLowerCase().includes("invalid api key") || branded.toLowerCase().includes("failed to validate api key"))) {
+          return;
+        }
         const brandedArgs = args.map((a) => typeof a === "string" ? rebrand(a) : a);
         const authLogger = new OpacaLogger(config.logger);
         switch (level) {
@@ -207,8 +206,8 @@ function sanitizeConfig(config, settings = {}) {
   const supportsAuth = ["sqlite", "postgres", "d1", "bun-sqlite", "better-sqlite3"].includes(config.db.name);
   const systemCollections = getSystemCollections();
   for (const systemCol of systemCollections) {
-    const isAsset = systemCol.slug === "_opaca_assets";
-    const isAuth = ["_users", "_sessions", "_accounts", "_verifications", "_api_keys", "_opaca_plugin_settings"].includes(systemCol.slug);
+    const isAsset = systemCol.slug === "_assets";
+    const isAuth = ["_users", "_sessions", "_accounts", "_verifications", "_api_keys"].includes(systemCol.slug);
     if (isAsset && config.storages || isAuth && supportsAuth) {
       if (!collections.find((col) => col.slug === systemCol.slug)) {
         collections.push({
@@ -218,6 +217,11 @@ function sanitizeConfig(config, settings = {}) {
       }
     }
   }
+  const serializeFn = (fn) => {
+    if (typeof fn !== "function")
+      return fn;
+    return `__opaca_fn__:${fn.toString()}`;
+  };
   const sanitizeField = (f) => ({
     name: f.name,
     type: f.type,
@@ -226,11 +230,15 @@ function sanitizeConfig(config, settings = {}) {
     unique: f.unique,
     defaultValue: f.defaultValue,
     localized: f.localized,
+    condition: serializeFn(f.condition),
+    requiredCondition: serializeFn(f.requiredCondition),
     admin: f.admin ? {
       description: f.admin.description,
       hidden: f.admin.hidden,
       readOnly: f.admin.readOnly,
-      components: f.admin.components
+      components: f.admin.components,
+      condition: serializeFn(f.admin.condition),
+      requiredCondition: serializeFn(f.admin.requiredCondition)
     } : undefined,
     options: f.options,
     fields: f.fields ? f.fields.map(sanitizeField) : undefined,
@@ -285,8 +293,12 @@ function sanitizeConfig(config, settings = {}) {
       adminAssets: p.adminAssets ? p.adminAssets() : undefined,
       adminUI: p.adminUI,
       settings: settings[p.name] || {},
-      configSchema: p.configSchema ? p.configSchema.map(sanitizeField) : undefined
-    }))
+      configSchema: p.configSchema ? (Array.isArray(p.configSchema) ? p.configSchema : (init_compiler(), __toCommonJS(exports_compiler)).zodToOpacaFields(p.configSchema)).map(sanitizeField) : undefined
+    })),
+    api: config.api ? {
+      rest: config.api.rest,
+      graphql: config.api.graphql
+    } : undefined
   };
 }