opacacms 0.1.21 → 0.2.1

package/dist/{chunk-ekxkvqjm.js → chunk-bygjkgrx.js}

@@ -3,17 +3,18 @@ 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";
@@ -21,15 +22,12 @@ import {
 // src/db/better-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 BetterSQLiteAdapter extends BaseDatabaseAdapter {
+  path;
   name = "better-sqlite3";
   _rawDb;
-  _db;
+  _db = null;
   _collections = [];
   _globals = [];
   push;
@@ -39,27 +37,39 @@ class BetterSQLiteAdapter 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) {
+    if (!this._db)
+      await this.connect();
     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) {
@@ -67,7 +77,7 @@ class BetterSQLiteAdapter extends BaseDatabaseAdapter {
     if (!colDef)
       return data;
     const result = { ...data };
-    const { flattenFields: flattenFields2 } = await import("./chunk-7fyepksb.js");
+    const { flattenFields: flattenFields2 } = await import("./chunk-526a3gqx.js");
     const allFields = flattenFields2(colDef.fields);
     for (const field of allFields) {
       const colName = toSnakeCase(field.name);
@@ -103,7 +113,7 @@ class BetterSQLiteAdapter 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));
     }
@@ -112,7 +122,7 @@ class BetterSQLiteAdapter 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) => ["richtext", "json", "file"].includes(f.type)).map((f) => f.name) || [];
       const flatData = flattenPayload(data, "", jsonFields);
@@ -193,7 +203,7 @@ class BetterSQLiteAdapter 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));
@@ -204,8 +214,8 @@ class BetterSQLiteAdapter extends BaseDatabaseAdapter {
     const unflattened = unflattenRow(row);
     const colDef = this._collections.find((c) => c.slug === collection);
     if (colDef) {
-      const { getRelationalFields, toSnakeCase: toSnakeCase2 } = await import("./chunk-7fyepksb.js");
-      const relationalFields = getRelationalFields(colDef.fields);
+      const { getRelationalFields: getRelationalFields2, toSnakeCase: toSnakeCase2 } = await import("./chunk-526a3gqx.js");
+      const relationalFields = getRelationalFields2(colDef.fields);
       for (const field of relationalFields) {
         if (!field.name)
           continue;
@@ -246,7 +256,7 @@ class BetterSQLiteAdapter 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));
     }
@@ -258,7 +268,87 @@ class BetterSQLiteAdapter 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),
@@ -275,7 +365,7 @@ class BetterSQLiteAdapter extends BaseDatabaseAdapter {
   }
   async update(collection, query, data) {
     const tableName = toSnakeCase(collection);
-    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 };
@@ -366,7 +456,7 @@ class BetterSQLiteAdapter extends BaseDatabaseAdapter {
     const current = await this.findOne(collection, normalizedQuery);
     if (!current)
       return false;
-    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) {
         for (const field of colDef.fields) {
@@ -392,7 +482,7 @@ class BetterSQLiteAdapter 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));
@@ -421,7 +511,7 @@ class BetterSQLiteAdapter 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));
@@ -455,7 +545,7 @@ class BetterSQLiteAdapter 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) {
@@ -469,15 +559,15 @@ class BetterSQLiteAdapter 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,
@@ -500,7 +590,7 @@ class BetterSQLiteAdapter 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-16vgcf3k.js → chunk-byq8g0rd.js}

@@ -1,6 +1,6 @@
 import {
   notify
-} from "./chunk-j4d50hrx.js";
+} from "./chunk-8scgdznr.js";
 
 // src/admin/stores/auth.ts
 import { atom, computed } from "nanostores";

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

@@ -1,23 +1,23 @@
-import {
-  logger
-} from "./chunk-62ev8gnc.js";
 import {
   flattenFields,
   getRelationalFields,
   mapFieldToPostgresType,
   mapFieldToSQLiteType,
   toSnakeCase
-} from "./chunk-2kyhqvhc.js";
+} from "./chunk-qxt9vge8.js";
 import {
   getSystemCollections,
   init_system_schema
-} from "./chunk-ybbbqj63.js";
+} from "./chunk-v9z61v3g.js";
+import {
+  logger
+} from "./chunk-t0zg026p.js";
 
 // src/db/kysely/data-mapper.ts
 function toCamelCase(str) {
   if (str.startsWith("_"))
     return str;
-  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+  return str.replace(/_+([a-z])/g, (_, letter) => letter.toUpperCase());
 }
 function flattenPayload(payload, prefix = "", excludeKeys = []) {
   if (typeof payload !== "object" || payload === null || Array.isArray(payload))
@@ -39,7 +39,7 @@ function flattenPayload(payload, prefix = "", excludeKeys = []) {
         if (value === undefined)
           continue;
         const colName = `${prefix}${toSnakeCase(key)}`;
-        if (typeof value === "object" && value !== null) {
+        if (typeof value === "object" && value !== null && !(value instanceof Date)) {
           result[colName] = JSON.stringify(value);
         } else {
           result[colName] = value;

package/dist/chunk-fj19qccp.js

@@ -0,0 +1,78 @@
+import {
+  pluginSyncCommand
+} from "./chunk-twpvxfce.js";
+import {
+  logger
+} from "./chunk-t0zg026p.js";
+import {
+  __require
+} from "./chunk-8sqjbsgt.js";
+
+// src/cli/commands/plugin-build.ts
+import fs from "node:fs";
+import path from "node:path";
+async function pluginBuildCommand(projectRoot) {
+  const srcDir = path.resolve(projectRoot, "src");
+  const distDir = path.resolve(projectRoot, "dist");
+  if (!fs.existsSync(srcDir)) {
+    logger.error(`No 'src' directory found in ${projectRoot}.`);
+    process.exit(1);
+  }
+  logger.info("Syncing plugin UI...");
+  await pluginSyncCommand(projectRoot, false);
+  const entryFiles = ["index.tsx", "index.ts", "plugin.tsx", "plugin.ts"];
+  let mainEntry = "";
+  for (const file of entryFiles) {
+    const fullPath = path.join(srcDir, file);
+    if (fs.existsSync(fullPath)) {
+      mainEntry = fullPath;
+      break;
+    }
+  }
+  if (!mainEntry) {
+    logger.error(`Could not find a main entry file in ${srcDir}`);
+    process.exit(1);
+  }
+  logger.info(`Building plugin entry: ${path.basename(mainEntry)}...`);
+  if (!fs.existsSync(distDir)) {
+    fs.mkdirSync(distDir, { recursive: true });
+  }
+  const buildResult = await Bun.build({
+    entrypoints: [mainEntry],
+    outdir: distDir,
+    target: "node",
+    format: "esm",
+    external: [
+      "opacacms",
+      "opacacms/types",
+      "opacacms/plugins",
+      "opacacms/schema",
+      "hono",
+      "zod",
+      "react",
+      "react-dom"
+    ]
+  });
+  if (!buildResult.success) {
+    logger.error("Plugin build failed.");
+    for (const msg of buildResult.logs) {
+      console.error(msg);
+    }
+    process.exit(1);
+  }
+  try {
+    logger.info("Generating type declarations...");
+    const { execSync } = await import("node:child_process");
+    execSync("bunx tsc --emitDeclarationOnly --outDir dist", {
+      cwd: projectRoot,
+      stdio: "ignore"
+    });
+    logger.success("Types generated.");
+  } catch (err) {
+    logger.warn("Failed to generate types. Make sure typescript is installed.");
+  }
+  logger.success(`Plugin built successfully in ${distDir}!`);
+}
+export {
+  pluginBuildCommand
+};

package/dist/{chunk-n1xraw7j.js → chunk-g1jb60xd.js}

@@ -4,7 +4,7 @@ import {
 
 // src/cli/commands/seed-command.ts
 async function seedCommand(opaca, count, reset, type) {
-  const { autoSeed } = await import("./chunk-nb7ctdg8.js");
+  const { autoSeed } = await import("./chunk-jdfw4v3r.js");
   try {
     await autoSeed(opaca, count, reset, type);
   } catch (error) {

package/dist/{chunk-xa7rjsn2.js → chunk-j53pz21t.js}

@@ -6,8 +6,8 @@ import {
   login,
   logout,
   syncSession
-} from "./chunk-16vgcf3k.js";
-import"./chunk-j4d50hrx.js";
+} from "./chunk-byq8g0rd.js";
+import"./chunk-8scgdznr.js";
 import"./chunk-8sqjbsgt.js";
 export {
   syncSession,

package/dist/{chunk-nb7ctdg8.js → chunk-jdfw4v3r.js}

@@ -203,7 +203,7 @@ function sortCollections(collections) {
 async function autoSeed(config, countPerCollection = 10, reset = false, type = "all") {
   const { collections, db, globals, storages, serverURL } = config;
   console.log(`\uD83C\uDF31 Starting automatic seed (${countPerCollection} records per collection)...`);
-  const { getSystemCollections } = await import("./chunk-v521d72w.js");
+  const { getSystemCollections } = await import("./chunk-3rdhbedb.js");
   const systemCollections = getSystemCollections().filter((c) => c.slug === "_opaca_assets");
   const allCollections = [...systemCollections, ...collections];
   let collectionsToSeed = sortCollections(allCollections);

package/dist/chunk-mkn49zmy.js

@@ -0,0 +1,102 @@
+import {
+  logger
+} from "./chunk-t0zg026p.js";
+import"./chunk-8sqjbsgt.js";
+
+// src/cli/commands/plugin-init.ts
+import fs from "node:fs";
+import path from "node:path";
+async function pluginInitCommand(pluginName) {
+  if (!pluginName) {
+    logger.error("Please provide a plugin name. Usage: opacacms plugin:init <plugin_name>");
+    process.exit(1);
+  }
+  const targetDir = path.resolve(process.cwd(), pluginName);
+  if (fs.existsSync(targetDir)) {
+    logger.error(`Directory ${targetDir} already exists.`);
+    process.exit(1);
+  }
+  logger.info(`Initializing new plugin in ${targetDir}...`);
+  fs.mkdirSync(targetDir, { recursive: true });
+  fs.mkdirSync(path.join(targetDir, "src"), { recursive: true });
+  const packageJson = {
+    name: pluginName,
+    version: "1.0.0",
+    description: "An OpacaCMS plugin",
+    main: "dist/index.js",
+    types: "dist/index.d.ts",
+    scripts: {
+      build: "opacacms plugin:build",
+      dev: "bun run build --watch"
+    },
+    peerDependencies: {
+      opacacms: "workspace:*"
+    },
+    devDependencies: {
+      typescript: "^5.0.0",
+      "@types/node": "^20.0.0"
+    }
+  };
+  fs.writeFileSync(path.join(targetDir, "package.json"), JSON.stringify(packageJson, null, 2), "utf-8");
+  const tsconfig = {
+    compilerOptions: {
+      target: "ESNext",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      forceConsistentCasingInFileNames: true,
+      outDir: "./dist",
+      declaration: true,
+      jsx: "react"
+    },
+    include: ["src/**/*"]
+  };
+  fs.writeFileSync(path.join(targetDir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2), "utf-8");
+  const indexTsx = `import type { OpacaPlugin, OpacaPluginContext } from 'opacacms/types';
+import { definePlugin } from 'opacacms/plugins';
+
+export const myPlugin = (): OpacaPlugin => definePlugin({
+  name: '${pluginName}',
+  label: 'My Custom Plugin',
+  description: 'A great new plugin for OpacaCMS.',
+  version: '1.0.0',
+  icon: 'Box',
+
+  onInit: (ctx: OpacaPluginContext) => {
+    ctx.logger.info('[${pluginName}] Plugin initialized!');
+    return ctx.config;
+  },
+
+  adminUI: {
+    component: 'my-plugin-dashboard',
+    // The CLI will automatically compile dashboard.tsx into this 'source' field during build.
+    source: '',
+  }
+});
+`;
+  fs.writeFileSync(path.join(targetDir, "src", "index.tsx"), indexTsx, "utf-8");
+  const dashboardTsx = `class MyPluginDashboard extends HTMLElement {
+  connectedCallback() {
+    this.innerHTML = \`
+      <div style="padding: 2rem; font-family: sans-serif;">
+        <h2>Welcome to ${pluginName} Dashboard!</h2>
+        <p>This UI component is built as a self-contained Web Component.</p>
+      </div>
+    \`;
+  }
+}
+
+customElements.define('my-plugin-dashboard', MyPluginDashboard);
+`;
+  fs.writeFileSync(path.join(targetDir, "src", "dashboard.tsx"), dashboardTsx, "utf-8");
+  logger.success(`Plugin ${pluginName} initialized successfully!`);
+  logger.info(`Next steps:
+  cd ${pluginName}
+  bun install
+  bun run build`);
+}
+export {
+  pluginInitCommand
+};