opacacms 0.1.21 → 0.2.1

package/dist/{chunk-v521d72w.js → chunk-3rdhbedb.js}

@@ -1,7 +1,7 @@
 import {
   getSystemCollections,
   init_system_schema
-} from "./chunk-ybbbqj63.js";
+} from "./chunk-v9z61v3g.js";
 import"./chunk-8sqjbsgt.js";
 init_system_schema();
 

package/dist/chunk-51z3x7kq.js

@@ -0,0 +1,20 @@
+// src/server/plugins-loader.ts
+async function loadPluginSettings(config) {
+  if (!config.db)
+    return {};
+  try {
+    const result = await config.db.find("_opaca_plugin_settings");
+    if (!result || !result.docs)
+      return {};
+    return result.docs.reduce((acc, curr) => {
+      if (curr.pluginName && curr.config) {
+        acc[curr.pluginName] = curr.config;
+      }
+      return acc;
+    }, {});
+  } catch (e) {
+    return {};
+  }
+}
+
+export { loadPluginSettings };

package/dist/{chunk-7fyepksb.js → chunk-526a3gqx.js}

@@ -4,7 +4,7 @@ import {
   mapFieldToPostgresType,
   mapFieldToSQLiteType,
   toSnakeCase
-} from "./chunk-2kyhqvhc.js";
+} from "./chunk-qxt9vge8.js";
 import"./chunk-8sqjbsgt.js";
 export {
   toSnakeCase,

package/dist/{chunk-0sdceeys.js → chunk-6d1vdfwa.js}

@@ -3,31 +3,31 @@ import {
   flattenPayload,
   pushSchema,
   unflattenRow
-} from "./chunk-cpw2y3pn.js";
+} from "./chunk-dykn5hr6.js";
 import {
   BaseDatabaseAdapter
 } from "./chunk-s8mqwnm1.js";
-import {
-  logger
-} from "./chunk-62ev8gnc.js";
 import {
   flattenFields,
   getRelationalFields,
   toSnakeCase
-} from "./chunk-2kyhqvhc.js";
+} from "./chunk-qxt9vge8.js";
+import {
+  logger
+} from "./chunk-t0zg026p.js";
+import {
+  __require
+} from "./chunk-8sqjbsgt.js";
 
 // src/db/sqlite.ts
 import fs from "node:fs/promises";
 import path from "node:path";
-import { createRequire } from "node:module";
 import { CompiledQuery, FileMigrationProvider, Kysely, Migrator, SqliteDialect } from "kysely";
-var require2 = createRequire(import.meta.url);
-var Database = require2("better-sqlite3");
-
 class SQLiteAdapter extends BaseDatabaseAdapter {
+  path;
   name = "sqlite";
   _rawDb;
-  _db;
+  _db = null;
   _collections = [];
   _globals = [];
   push;
@@ -37,27 +37,37 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
     return this._rawDb;
   }
   get db() {
+    if (!this._db)
+      throw new Error("Database not connected. Call connect() first.");
     return this._db;
   }
   constructor(path2, options) {
     super();
-    this._rawDb = new Database(path2);
+    this.path = path2;
+    this.push = options?.push ?? true;
+    this.pushDestructive = options?.pushDestructive ?? false;
+    this.migrationDir = options?.migrationDir ?? "./migrations";
+  }
+  async connect() {
+    if (this._db)
+      return;
+    const { createRequire } = await import("node:module");
+    const require2 = createRequire(import.meta.url);
+    const Database = require2("better-sqlite3");
+    this._rawDb = new Database(this.path);
     this._db = new Kysely({
       dialect: new SqliteDialect({
         database: this._rawDb
       })
     });
-    this.push = options?.push ?? true;
-    this.pushDestructive = options?.pushDestructive ?? false;
-    this.migrationDir = options?.migrationDir ?? "./migrations";
   }
-  async connect() {}
   async disconnect() {
-    await this._db.destroy();
+    if (this._db)
+      await this.db.destroy();
   }
   async unsafe(query, params) {
     const compiled = CompiledQuery.raw(query, params || []);
-    const result = await this._db.executeQuery(compiled);
+    const result = await this.db.executeQuery(compiled);
     return result.rows;
   }
   async coerceData(collection, data) {
@@ -100,7 +110,7 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
   }
   async count(collection, query) {
     const tableName = toSnakeCase(collection);
-    let qb = this._db.selectFrom(tableName).select((eb) => eb.fn.count("id").as("count"));
+    let qb = this.db.selectFrom(tableName).select((eb) => eb.fn.count("id").as("count"));
     if (query && Object.keys(query).length > 0) {
       qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
     }
@@ -109,7 +119,7 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
   }
   async create(collection, data) {
     const tableName = toSnakeCase(collection);
-    return this._db.transaction().execute(async (tx) => {
+    return this.db.transaction().execute(async (tx) => {
       const colDef = this._collections.find((c) => c.slug === collection);
       const jsonFields = colDef?.fields.filter((f) => f.name && (["richtext", "json", "file"].includes(f.type) || f.localized)).map((f) => f.name) || [];
       const flatData = flattenPayload(data, "", jsonFields);
@@ -186,7 +196,7 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
   }
   async findOne(collection, query, tx) {
     const tableName = toSnakeCase(collection);
-    const executor = tx || this._db;
+    const executor = tx || this.db;
     let qb = executor.selectFrom(tableName).selectAll();
     if (query && Object.keys(query).length > 0) {
       qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
@@ -252,7 +262,7 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
     const offset = (page - 1) * limit;
     const total = await this.count(collection, query);
     const tableName = toSnakeCase(collection);
-    let qb = this._db.selectFrom(tableName).selectAll().limit(limit).offset(offset);
+    let qb = this.db.selectFrom(tableName).selectAll().limit(limit).offset(offset);
     if (query && Object.keys(query).length > 0) {
       qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
     }
@@ -265,7 +275,87 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
       qb = qb.orderBy("created_at", "desc");
     }
     const rows = await qb.execute();
-    const docs = await Promise.all(rows.map((row) => this.findOne(collection, { id: row.id })));
+    if (rows.length === 0) {
+      const totalPages2 = Math.ceil(total / limit);
+      return {
+        docs: [],
+        totalDocs: total,
+        limit,
+        totalPages: totalPages2,
+        page,
+        pagingCounter: offset + 1,
+        hasNextPage: page * limit < total,
+        hasPrevPage: page > 1,
+        prevPage: page > 1 ? page - 1 : null,
+        nextPage: page < totalPages2 ? page + 1 : null
+      };
+    }
+    const rowIds = rows.map((r) => r.id);
+    const docs = rows.map((r) => unflattenRow(r));
+    const colDef = this._collections.find((c) => c.slug === collection);
+    if (colDef) {
+      const relationalFields = getRelationalFields(colDef.fields);
+      for (const field of relationalFields) {
+        if (!field.name)
+          continue;
+        const snakeName = toSnakeCase(field.name);
+        if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+          const joinTableName = `${toSnakeCase(collection)}_${snakeName}_relations`.toLowerCase();
+          try {
+            const allRelations = await this.db.selectFrom(joinTableName).selectAll().where("source_id", "in", rowIds).orderBy("order", "asc").execute();
+            const relationsBySource = allRelations.reduce((acc, r) => {
+              if (!acc[r.source_id])
+                acc[r.source_id] = [];
+              acc[r.source_id].push(r.target_id);
+              return acc;
+            }, {});
+            const parts = field.name.split("__");
+            for (let docIdx = 0;docIdx < docs.length; docIdx++) {
+              const rowId = rowIds[docIdx];
+              let current = docs[docIdx];
+              for (let i = 0;i < parts.length - 1; i++) {
+                if (!current[parts[i]])
+                  current[parts[i]] = {};
+                current = current[parts[i]];
+              }
+              current[parts[parts.length - 1]] = relationsBySource[rowId] || [];
+            }
+          } catch (e) {}
+        } else if (field.type === "blocks" && field.blocks) {
+          const blocksBySource = {};
+          for (const b of field.blocks) {
+            const blockTableName = `${collection}_${snakeName}_${toSnakeCase(b.slug)}`.toLowerCase();
+            try {
+              const allBlocks = await this.db.selectFrom(blockTableName).selectAll().where("_parent_id", "in", rowIds).execute();
+              for (const blk of allBlocks) {
+                const uf = unflattenRow(blk);
+                uf.blockType = blk.block_type;
+                if (!blocksBySource[blk._parent_id])
+                  blocksBySource[blk._parent_id] = [];
+                blocksBySource[blk._parent_id].push(uf);
+              }
+            } catch (e) {}
+          }
+          const parts = field.name.split("__");
+          for (let docIdx = 0;docIdx < docs.length; docIdx++) {
+            const rowId = rowIds[docIdx];
+            const blockData = blocksBySource[rowId] || [];
+            blockData.sort((a, b) => a._order - b._order);
+            blockData.forEach((b) => {
+              delete b._order;
+              delete b._parentId;
+            });
+            let current = docs[docIdx];
+            for (let i = 0;i < parts.length - 1; i++) {
+              if (!current[parts[i]])
+                current[parts[i]] = {};
+              current = current[parts[i]];
+            }
+            current[parts[parts.length - 1]] = blockData;
+          }
+        }
+      }
+    }
     const totalPages = Math.ceil(total / limit);
     return {
       docs: docs.filter(Boolean),
@@ -281,7 +371,7 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
     };
   }
   async update(collection, query, data) {
-    return this._db.transaction().execute(async (tx) => {
+    return this.db.transaction().execute(async (tx) => {
       let normalizedQuery = query;
       if (typeof query !== "object" || query === null) {
         normalizedQuery = { id: query };
@@ -374,7 +464,7 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
     if (!current)
       return false;
     const tableName = toSnakeCase(collection);
-    await this._db.transaction().execute(async (tx) => {
+    await this.db.transaction().execute(async (tx) => {
       const colDef = this._collections.find((c) => c.slug === collection);
       if (colDef) {
         const relationalFields = getRelationalFields(colDef.fields);
@@ -403,7 +493,7 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
   }
   async updateMany(collection, query, data) {
     const tableName = toSnakeCase(collection);
-    return this._db.transaction().execute(async (tx) => {
+    return this.db.transaction().execute(async (tx) => {
       let qb = tx.updateTable(tableName);
       if (query && Object.keys(query).length > 0) {
         qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
@@ -432,7 +522,7 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
   }
   async deleteMany(collection, query) {
     const tableName = toSnakeCase(collection);
-    return this._db.transaction().execute(async (tx) => {
+    return this.db.transaction().execute(async (tx) => {
       let selectQb = tx.selectFrom(tableName).select("id");
       if (query && Object.keys(query).length > 0) {
         selectQb = selectQb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
@@ -469,7 +559,7 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
   }
   async findGlobal(slug) {
     const tableName = toSnakeCase(slug);
-    const row = await this._db.selectFrom(tableName).selectAll().limit(1).executeTakeFirst();
+    const row = await this.db.selectFrom(tableName).selectAll().limit(1).executeTakeFirst();
     return row ? unflattenRow(row) : null;
   }
   async updateGlobal(slug, data) {
@@ -482,15 +572,15 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
       if (!flatData.id)
         flatData.id = "global";
       flatData[toSnakeCase("createdAt")] = now;
-      await this._db.insertInto(tableName).values(flatData).execute();
+      await this.db.insertInto(tableName).values(flatData).execute();
     } else {
-      await this._db.updateTable(tableName).set(flatData).where("id", "=", existing.id).execute();
+      await this.db.updateTable(tableName).set(flatData).where("id", "=", existing.id).execute();
     }
     return this.findGlobal(slug);
   }
   async runMigrations() {
     const migrator = new Migrator({
-      db: this._db,
+      db: this.db,
       provider: new FileMigrationProvider({
         fs,
         path,
@@ -513,7 +603,7 @@ class SQLiteAdapter extends BaseDatabaseAdapter {
     this._collections = collections;
     this._globals = globals;
     if (this.push) {
-      await pushSchema(this._db, "sqlite", collections, globals, {
+      await pushSchema(this.db, "sqlite", collections, globals, {
         pushDestructive: this.pushDestructive
       });
     }

package/dist/{chunk-wmvjvn7b.js → chunk-6qq3ne6b.js}

@@ -3,7 +3,7 @@ import {
   mapFieldToPostgresType,
   mapFieldToSQLiteType,
   toSnakeCase
-} from "./chunk-2kyhqvhc.js";
+} from "./chunk-qxt9vge8.js";
 import"./chunk-8sqjbsgt.js";
 
 // src/db/kysely/migration-generator.ts
@@ -60,6 +60,26 @@ function generateMigrationCode(collections, globals = [], dialect) {
 `;
     downCode = `  await db.schema.dropTable('${slug}').execute();
 ` + downCode;
+    if ("versions" in collection && collection.versions) {
+      const versionsTable = `${toSnakeCase(slug)}_versions`;
+      upCode += `  await db.schema.createTable('${versionsTable}')
+`;
+      upCode += `    .addColumn('id', 'text', (col) => col.primaryKey())
+`;
+      upCode += `    .addColumn('_parent_id', 'text', (col) => col.notNull())
+`;
+      upCode += `    .addColumn('_version_data', '${dialect === "postgres" ? "jsonb" : "text"}', (col) => col.notNull())
+`;
+      upCode += `    .addColumn('_status', 'text')
+`;
+      upCode += `    .addColumn('created_at', '${tsType}', (col) => col.defaultTo(sql\`CURRENT_TIMESTAMP\`))
+`;
+      upCode += `    .execute();
+
+`;
+      downCode = `  await db.schema.dropTable('${versionsTable}').execute();
+` + downCode;
+    }
     for (const field of flattenedFields) {
       if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
         const colName = toSnakeCase(field.name);
@@ -188,6 +208,24 @@ function generateSQLCode(collections, globals = []) {
 );
 
 `;
+    if ("versions" in collection && collection.versions) {
+      const versionsTable = `${toSnakeCase(slug)}_versions`;
+      sql += `CREATE TABLE IF NOT EXISTS "${versionsTable}" (
+`;
+      sql += `  "id" TEXT PRIMARY KEY,
+`;
+      sql += `  "_parent_id" TEXT NOT NULL,
+`;
+      sql += `  "_version_data" TEXT NOT NULL,
+`;
+      sql += `  "_status" TEXT,
+`;
+      sql += `  "created_at" TEXT DEFAULT CURRENT_TIMESTAMP
+`;
+      sql += `);
+
+`;
+    }
     for (const field of flattenedFields) {
       if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
         const colName = toSnakeCase(field.name);

package/dist/{chunk-0am1m47g.js → chunk-6v1fw7q7.js}

@@ -1,6 +1,6 @@
 import {
   logger
-} from "./chunk-62ev8gnc.js";
+} from "./chunk-t0zg026p.js";
 import {
   __require
 } from "./chunk-8sqjbsgt.js";
@@ -17,8 +17,8 @@ async function migrateCreateCommand(opaca, migrationName = "migration", outDir)
     fs.mkdirSync(fullMigrationDir, { recursive: true });
   }
   const timestamp = new Date().toISOString().replace(/[-:T]/g, "").split(".")[0];
-  const { generateMigrationCode, generateSQLCode } = await import("./chunk-wmvjvn7b.js");
-  const { getSystemCollections } = await import("./chunk-v521d72w.js");
+  const { generateMigrationCode, generateSQLCode } = await import("./chunk-6qq3ne6b.js");
+  const { getSystemCollections } = await import("./chunk-3rdhbedb.js");
   let dialect = "sqlite";
   if (db.name === "postgres")
     dialect = "postgres";
@@ -104,9 +104,9 @@ async function migrateD1Command(migrationDir, isRemote, binding = "DB") {
       isRemote ? "--remote" : "--local",
       "--yes"
     ];
-    const result = spawnSync("bunx", wranglerArgs, {
+    const result = spawnSync("bun", ["x", ...wranglerArgs], {
       stdio: "inherit",
-      shell: true,
+      shell: false,
       cwd: process.cwd()
     });
     if (result.status !== 0) {

package/dist/{chunk-t9v845m2.js → chunk-7y1nbmw6.js}

@@ -1,3 +1,7 @@
+import {
+  logger
+} from "./chunk-t0zg026p.js";
+
 // src/validation.ts
 import { z } from "zod";
 var FieldTypeSchema = z.enum([
@@ -20,7 +24,8 @@ var FieldTypeSchema = z.enum([
   "tabs",
   "join",
   "array",
-  "virtual"
+  "virtual",
+  "ui"
 ]);
 var BaseFieldSchema = z.object({
   name: z.string(),
@@ -41,7 +46,8 @@ var BaseFieldSchema = z.object({
     components: z.object({
       Field: z.string().optional(),
       Cell: z.string().optional()
-    }).optional()
+    }).optional(),
+    customProps: z.record(z.string(), z.any()).optional()
   }).optional()
 });
 var FieldSchema = z.lazy(() => z.discriminatedUnion("type", [
@@ -154,6 +160,9 @@ var FieldSchema = z.lazy(() => z.discriminatedUnion("type", [
     type: z.literal("virtual"),
     resolve: z.function(),
     returnType: z.string().optional()
+  }),
+  BaseFieldSchema.extend({
+    type: z.literal("ui")
   })
 ]));
 var AccessConfigSchema = z.object({
@@ -266,6 +275,11 @@ var OpacaAuthConfigSchema = z.object({
       enabled: z.boolean(),
       issuer: z.string()
     }).optional()
+  }).optional(),
+  logger: z.object({
+    disabled: z.boolean().optional(),
+    disableColors: z.boolean().optional(),
+    level: z.enum(["debug", "info", "warn", "error"]).optional()
   }).optional()
 });
 var ApiConfigSchema = z.object({
@@ -277,9 +291,19 @@ var ApiConfigSchema = z.object({
     store: z.any().optional(),
     provider: z.function().optional(),
     keyGenerator: z.function().optional()
+  }).optional(),
+  openAPI: z.object({
+    enabled: z.boolean().optional().default(false),
+    path: z.string().optional().default("/reference"),
+    theme: z.string().optional(),
+    layout: z.string().optional(),
+    hideModels: z.boolean().optional(),
+    hideDownloadButton: z.boolean().optional(),
+    customCss: z.string().optional()
   }).optional()
 });
 var OpacaConfigSchema = z.object({
+  plugins: z.array(z.any()).optional(),
   collections: z.array(CollectionSchema),
   globals: z.array(GlobalSchema).optional(),
   db: z.any(),
@@ -321,7 +345,14 @@ function recursivelyBuild(obj) {
   return built;
 }
 function defineConfig(config) {
-  const builtConfig = recursivelyBuild(config);
+  let builtConfig = recursivelyBuild(config);
+  if (builtConfig.plugins && Array.isArray(builtConfig.plugins)) {
+    for (const plugin of builtConfig.plugins) {
+      if (plugin.onInit) {
+        builtConfig = plugin.onInit({ config: builtConfig, logger }) || builtConfig;
+      }
+    }
+  }
   const result = OpacaConfigSchema.safeParse(builtConfig);
   if (!result.success) {
     throw new Error(`Invalid OpacaCMS Configuration: ${result.error.message}`);

package/dist/chunk-8scgdznr.js

@@ -0,0 +1,44 @@
+// src/admin/stores/ui.ts
+import { persistentAtom } from "@nanostores/persistent";
+import { atom } from "nanostores";
+var $toasts = atom([]);
+var $isSidebarCollapsed = persistentAtom("opaca-sidebar-collapsed", false, {
+  encode: JSON.stringify,
+  decode: JSON.parse
+});
+function toggleSidebar() {
+  $isSidebarCollapsed.set(!$isSidebarCollapsed.get());
+}
+function notify(message, type = "success") {
+  const id = Math.random().toString(36).substring(2, 9);
+  $toasts.set([...$toasts.get(), { id, message, type }]);
+}
+function clearToast(id) {
+  $toasts.set($toasts.get().filter((t) => t.id !== id));
+}
+var $customSidebarItems = atom([]);
+function registerSidebarItem(item) {
+  const current = $customSidebarItems.get();
+  if (!current.find((i) => i.path === item.path)) {
+    if (item.render && !item.component) {
+      item.component = `opaca-plugin-render-${Math.random().toString(36).substring(2, 9)}`;
+      if (typeof customElements !== "undefined" && !customElements.get(item.component)) {
+        const componentName = item.component;
+        const renderFn = item.render;
+
+        class OpacaGenericPlugin extends HTMLElement {
+          connectedCallback() {
+            const serverUrl = this.getAttribute("server-url") || "";
+            const config = JSON.parse(this.getAttribute("config") || "{}");
+            const user = JSON.parse(this.getAttribute("user") || "{}");
+            this.innerHTML = renderFn(serverUrl, config, user);
+          }
+        }
+        customElements.define(componentName, OpacaGenericPlugin);
+      }
+    }
+    $customSidebarItems.set([...current, item]);
+  }
+}
+
+export { $toasts, $isSidebarCollapsed, toggleSidebar, notify, clearToast, $customSidebarItems, registerSidebarItem };

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

@@ -1,12 +1,15 @@
 import {
   getSystemCollections,
   init_system_schema
-} from "./chunk-ybbbqj63.js";
+} from "./chunk-v9z61v3g.js";
+import {
+  OpacaLogger
+} from "./chunk-t0zg026p.js";
 
 // src/auth/index.ts
 import { apiKey } from "@better-auth/api-key";
 import { betterAuth } from "better-auth";
-import { admin } from "better-auth/plugins";
+import { admin, openAPI } from "better-auth/plugins";
 import { CamelCasePlugin } from "kysely";
 
 // src/auth/premissions.ts
@@ -81,6 +84,10 @@ async function createAuth(config) {
       ac,
       roles
     }),
+    openAPI({
+      disableDefaultReference: true,
+      path: "/open-api"
+    }),
     ...userAuth.features?.apiKeys?.enabled ? [
       apiKey({
         defaultPrefix: "opaca_",
@@ -158,19 +165,50 @@ async function createAuth(config) {
         }
       }
     },
-    plugins
+    plugins,
+    logger: {
+      disabled: config.logger?.disabled,
+      disableColors: config.logger?.disableColors,
+      level: config.logger?.level,
+      log: (level, message, ...args) => {
+        const rebrand = (msg) => {
+          if (typeof msg !== "string")
+            return String(msg);
+          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);
+        const brandedArgs = args.map((a) => typeof a === "string" ? rebrand(a) : a);
+        const authLogger = new OpacaLogger(config.logger);
+        switch (level) {
+          case "debug":
+            authLogger.debug(branded, ...brandedArgs);
+            break;
+          case "info":
+            authLogger.info(branded, ...brandedArgs);
+            break;
+          case "warn":
+            authLogger.warn(branded, ...brandedArgs);
+            break;
+          case "error":
+            authLogger.error(branded, ...brandedArgs);
+            break;
+          default:
+            authLogger.info(branded, ...brandedArgs);
+        }
+      }
+    }
   });
 }
 
 // src/config-utils.ts
 init_system_schema();
-function sanitizeConfig(config) {
+function sanitizeConfig(config, settings = {}) {
   const collections = [...config.collections];
   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"].includes(systemCol.slug);
+    const isAuth = ["_users", "_sessions", "_accounts", "_verifications", "_api_keys", "_opaca_plugin_settings"].includes(systemCol.slug);
     if (isAsset && config.storages || isAuth && supportsAuth) {
       if (!collections.find((col) => col.slug === systemCol.slug)) {
         collections.push({
@@ -235,7 +273,20 @@ function sanitizeConfig(config) {
       acc[key] = {};
       return acc;
     }, {}) : {},
-    i18n: config.i18n
+    i18n: config.i18n,
+    plugins: config.plugins?.map((p) => ({
+      name: p.name,
+      label: p.label,
+      description: p.description,
+      version: p.version,
+      author: p.author,
+      homepage: p.homepage,
+      icon: p.icon,
+      adminAssets: p.adminAssets ? p.adminAssets() : undefined,
+      adminUI: p.adminUI,
+      settings: settings[p.name] || {},
+      configSchema: p.configSchema ? p.configSchema.map(sanitizeField) : undefined
+    }))
   };
 }
 

package/dist/chunk-bexcv7xe.js

@@ -0,0 +1,36 @@
+import {
+  defineCustomField
+} from "./chunk-rqyjjqgy.js";
+
+// src/admin/react.tsx
+import React from "react";
+import { createRoot } from "react-dom/client";
+function defineReactField(tagName, Component) {
+  defineCustomField(tagName, {
+    mount: (container, props) => {
+      const el = container;
+      const root = createRoot(el);
+      el._opacaReactRoot = root;
+      root.render(React.createElement(Component, props));
+    },
+    update: (container, props) => {
+      const el = container;
+      const root = el._opacaReactRoot;
+      if (root) {
+        root.render(React.createElement(Component, props));
+      }
+    },
+    unmount: (container) => {
+      const el = container;
+      const root = el._opacaReactRoot;
+      if (root) {
+        setTimeout(() => {
+          root.unmount();
+          delete el._opacaReactRoot;
+        }, 0);
+      }
+    }
+  });
+}
+
+export { defineReactField };