opacacms 0.1.9 → 0.1.11

package/dist/api.js

@@ -4,7 +4,7 @@ import {
   createGlobalHandlers,
   createHandlers,
   hydrateDoc
-} from "./chunk-hmhcense.js";
+} from "./chunk-0nf7fe26.js";
 import {
   defineConfig
 } from "./chunk-zvwb67nd.js";

package/dist/{chunk-hmhcense.js → chunk-0nf7fe26.js}

@@ -14,6 +14,7 @@ import {
   init_system_schema
 } from "./chunk-ybbbqj63.js";
 import {
+  __require,
   __toCommonJS
 } from "./chunk-8sqjbsgt.js";
 
@@ -1000,7 +1001,6 @@ function createDatabaseInitMiddleware(config, state) {
 }
 
 // src/server/middlewares/rate-limit.ts
-import { WorkersKVStore } from "@hono-rate-limiter/cloudflare";
 import { rateLimiter } from "hono-rate-limiter";
 function createRateLimitMiddleware(config) {
   const rateLimitConfig = config.api?.rateLimit;
@@ -1028,7 +1028,12 @@ function createRateLimitMiddleware(config) {
     if (!resolvedStore && c.env) {
       const kvBindingKey = Object.keys(c.env).find((key) => key.startsWith("OPACA_") && c.env[key]?.put && c.env[key]?.get);
       if (kvBindingKey) {
-        resolvedStore = new WorkersKVStore({ namespace: c.env[kvBindingKey] });
+        try {
+          const { WorkersKVStore } = await import("@hono-rate-limiter/cloudflare");
+          resolvedStore = new WorkersKVStore({ namespace: c.env[kvBindingKey] });
+        } catch (e) {
+          logger.error("Failed to load @hono-rate-limiter/cloudflare dynamic import. Make sure you are in a Cloudflare environment.", e);
+        }
       }
     }
     const limiter = rateLimiter({

package/dist/chunk-eqtsfyjf.js

@@ -0,0 +1,499 @@
+import {
+  buildKyselyWhere,
+  flattenPayload,
+  pushSchema,
+  unflattenRow
+} from "./chunk-6ew02s0c.js";
+import {
+  BaseDatabaseAdapter
+} from "./chunk-s8mqwnm1.js";
+import {
+  logger
+} from "./chunk-62ev8gnc.js";
+import {
+  flattenFields,
+  toSnakeCase
+} from "./chunk-cvdd4eqh.js";
+import {
+  __require
+} from "./chunk-8sqjbsgt.js";
+
+// 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 {
+  name = "better-sqlite3";
+  _rawDb;
+  _db;
+  _collections = [];
+  push;
+  migrationDir;
+  pushDestructive;
+  get raw() {
+    return this._rawDb;
+  }
+  get db() {
+    return this._db;
+  }
+  constructor(path2, options) {
+    super();
+    this._rawDb = new Database(path2);
+    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();
+  }
+  async unsafe(query, params) {
+    const compiled = CompiledQuery.raw(query, params || []);
+    const result = await this._db.executeQuery(compiled);
+    return result.rows;
+  }
+  async coerceData(collection, data) {
+    const colDef = this._collections.find((c) => c.slug === collection);
+    if (!colDef)
+      return data;
+    const result = { ...data };
+    const { flattenFields: flattenFields2 } = await import("./chunk-xg35h5a3.js");
+    const allFields = flattenFields2(colDef.fields);
+    for (const field of allFields) {
+      const colName = toSnakeCase(field.name);
+      if (!(colName in result))
+        continue;
+      const value = result[colName];
+      if (value === undefined || value === null)
+        continue;
+      switch (field.type) {
+        case "boolean":
+          result[colName] = value ? 1 : 0;
+          break;
+        case "number":
+          result[colName] = Number(value);
+          break;
+        case "date":
+          if (value instanceof Date) {
+            result[colName] = value.toISOString();
+          } else if (typeof value === "string") {
+            result[colName] = new Date(value).toISOString();
+          }
+          break;
+        case "richtext":
+        case "json":
+        case "file":
+          if (typeof value === "object") {
+            result[colName] = JSON.stringify(value);
+          }
+          break;
+      }
+    }
+    return result;
+  }
+  async count(collection, query) {
+    let qb = this._db.selectFrom(collection).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));
+    }
+    const result = await qb.executeTakeFirst();
+    return Number(result?.count || 0);
+  }
+  async create(collection, data) {
+    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);
+      for (const field of jsonFields) {
+        if (flatData[field] && typeof flatData[field] === "object") {
+          flatData[field] = JSON.stringify(flatData[field]);
+        }
+      }
+      const hasManyData = {};
+      const blocksData = {};
+      for (const key in flatData) {
+        if (Array.isArray(flatData[key])) {
+          const isHasMany = colDef?.fields.some((f) => f.type === "relationship" && ("hasMany" in f) && f.hasMany && f.name === key);
+          if (isHasMany) {
+            hasManyData[key] = flatData[key];
+          } else {
+            blocksData[key] = flatData[key];
+          }
+          delete flatData[key];
+        }
+      }
+      if (!flatData.id)
+        flatData.id = crypto.randomUUID();
+      const dbFields = flattenFields(colDef?.fields || []);
+      const validCols = new Set(dbFields.map((f) => toSnakeCase(f.name)));
+      validCols.add("id");
+      const ts = colDef?.timestamps !== false;
+      if (ts) {
+        const config = typeof colDef?.timestamps === "object" ? colDef.timestamps : {};
+        validCols.add(toSnakeCase(config.createdAt || "createdAt"));
+        validCols.add(toSnakeCase(config.updatedAt || "updatedAt"));
+      }
+      const filteredData = {};
+      for (const col of Object.keys(flatData)) {
+        if (validCols.has(col)) {
+          filteredData[col] = flatData[col];
+        }
+      }
+      const coercedData = await this.coerceData(collection, filteredData);
+      await tx.insertInto(collection).values(coercedData).execute();
+      for (const [key, values] of Object.entries(hasManyData)) {
+        const joinTableName = `${collection}_${toSnakeCase(key)}_relations`.toLowerCase();
+        if (values.length > 0) {
+          const joinData = values.map((val, idx) => {
+            const tId = typeof val === "object" ? val.id : val;
+            return { id: crypto.randomUUID(), source_id: flatData.id, target_id: tId, order: idx };
+          });
+          await tx.insertInto(joinTableName).values(joinData).execute();
+        }
+      }
+      for (const [key, blocks] of Object.entries(blocksData)) {
+        for (let i = 0;i < blocks.length; i++) {
+          const block = blocks[i];
+          if (!block.blockType)
+            continue;
+          const blockTableName = `${collection}_${toSnakeCase(key)}_${block.blockType}`.toLowerCase();
+          const bId = block.id || crypto.randomUUID();
+          const blockDef = colDef?.fields.find((f) => f.name === key && f.type === "blocks");
+          const blockConfig = blockDef?.blocks?.find((b) => b.slug === block.blockType);
+          const blockJsonFields = blockConfig?.fields.filter((f) => ["richtext", "json", "file"].includes(f.type)).map((f) => f.name) || [];
+          const blockFlatData = flattenPayload({ ...block, id: bId }, "", blockJsonFields);
+          for (const f of blockJsonFields) {
+            if (blockFlatData[f] && typeof blockFlatData[f] === "object") {
+              blockFlatData[f] = JSON.stringify(blockFlatData[f]);
+            }
+          }
+          delete blockFlatData.blockType;
+          const coercedBlockData = await this.coerceData(blockTableName, {
+            ...blockFlatData,
+            _parent_id: flatData.id,
+            _order: i,
+            block_type: block.blockType
+          });
+          await tx.insertInto(blockTableName).values(coercedBlockData).execute();
+        }
+      }
+      return this.findOne(collection, { id: flatData.id }, tx);
+    });
+  }
+  async findOne(collection, query, tx) {
+    const executor = tx || this._db;
+    let qb = executor.selectFrom(collection).selectAll();
+    if (query && Object.keys(query).length > 0) {
+      qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
+    }
+    const row = await qb.executeTakeFirst();
+    if (!row)
+      return null;
+    const unflattened = unflattenRow(row);
+    const colDef = this._collections.find((c) => c.slug === collection);
+    if (colDef) {
+      const { getRelationalFields, toSnakeCase: toSnakeCase2 } = await import("./chunk-xg35h5a3.js");
+      const relationalFields = getRelationalFields(colDef.fields);
+      for (const field of relationalFields) {
+        if (!field.name)
+          continue;
+        const snakeName = toSnakeCase2(field.name);
+        if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+          const joinTableName = `${collection}_${snakeName}_relations`.toLowerCase();
+          try {
+            const relations = await executor.selectFrom(joinTableName).selectAll().where("source_id", "=", row.id).orderBy("order", "asc").execute();
+            unflattened[field.name] = relations.map((r) => r.target_id);
+          } catch (e) {}
+        } else if (field.type === "blocks" && field.blocks) {
+          const blockData = [];
+          for (const b of field.blocks) {
+            const blockTableName = `${collection}_${snakeName}_${b.slug}`.toLowerCase();
+            try {
+              const blocks = await executor.selectFrom(blockTableName).selectAll().where("_parent_id", "=", row.id).execute();
+              for (const blk of blocks) {
+                const uf = unflattenRow(blk);
+                uf.blockType = blk.block_type;
+                blockData.push(uf);
+              }
+            } catch (e) {}
+          }
+          blockData.sort((a, b) => a._order - b._order);
+          blockData.forEach((b) => {
+            delete b._order;
+            delete b._parent_id;
+          });
+          unflattened[field.name] = blockData;
+        }
+      }
+    }
+    return unflattened;
+  }
+  async find(collection, query, options) {
+    const page = options?.page || 1;
+    const limit = options?.limit || 10;
+    const offset = (page - 1) * limit;
+    const total = await this.count(collection, query);
+    let qb = this._db.selectFrom(collection).selectAll().limit(limit).offset(offset);
+    if (query && Object.keys(query).length > 0) {
+      qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
+    }
+    if (options?.sort) {
+      const isDesc = options.sort.startsWith("-");
+      const col = isDesc ? options.sort.substring(1) : options.sort;
+      qb = qb.orderBy(col, isDesc ? "desc" : "asc");
+    } else {
+      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 })));
+    const totalPages = Math.ceil(total / limit);
+    return {
+      docs: docs.filter(Boolean),
+      totalDocs: total,
+      limit,
+      totalPages,
+      page,
+      pagingCounter: offset + 1,
+      hasNextPage: page * limit < total,
+      hasPrevPage: page > 1,
+      prevPage: page > 1 ? page - 1 : null,
+      nextPage: page < totalPages ? page + 1 : null
+    };
+  }
+  async update(collection, query, data) {
+    return this._db.transaction().execute(async (tx) => {
+      let normalizedQuery = query;
+      if (typeof query !== "object" || query === null) {
+        normalizedQuery = { id: query };
+      }
+      const current = await this.findOne(collection, normalizedQuery, tx);
+      if (!current)
+        throw new Error("Document not found");
+      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);
+      for (const field of jsonFields) {
+        if (flatData[field] && typeof flatData[field] === "object") {
+          flatData[field] = JSON.stringify(flatData[field]);
+        }
+      }
+      const hasManyData = {};
+      const blocksData = {};
+      for (const key in flatData) {
+        if (Array.isArray(flatData[key])) {
+          const isHasMany = colDef?.fields.some((f) => f.type === "relationship" && ("hasMany" in f) && f.hasMany && f.name === key);
+          if (isHasMany) {
+            hasManyData[key] = flatData[key];
+          } else {
+            blocksData[key] = flatData[key];
+          }
+          delete flatData[key];
+        }
+      }
+      flatData.updated_at = new Date().toISOString();
+      if (Object.keys(flatData).length > 0) {
+        const coercedData = await this.coerceData(collection, flatData);
+        await tx.updateTable(collection).set(coercedData).where("id", "=", current.id).execute();
+      }
+      for (const [key, values] of Object.entries(hasManyData)) {
+        const joinTableName = `${collection}_${toSnakeCase(key)}_relations`.toLowerCase();
+        await tx.deleteFrom(joinTableName).where("source_id", "=", current.id).execute();
+        if (values.length > 0) {
+          const joinData = values.map((val, idx) => {
+            const tId = typeof val === "object" ? val.id : val;
+            return { id: crypto.randomUUID(), source_id: current.id, target_id: tId, order: idx };
+          });
+          await tx.insertInto(joinTableName).values(joinData).execute();
+        }
+      }
+      for (const [key, blocks] of Object.entries(blocksData)) {
+        const fieldDef = colDef?.fields.find((f) => f.name === key);
+        if (fieldDef?.type === "blocks" && fieldDef.blocks) {
+          for (const b of fieldDef.blocks) {
+            const blockTableName = `${collection}_${toSnakeCase(key)}_${b.slug}`.toLowerCase();
+            try {
+              await tx.deleteFrom(blockTableName).where("_parent_id", "=", current.id).execute();
+            } catch (e) {}
+          }
+        }
+        for (let i = 0;i < blocks.length; i++) {
+          const block = blocks[i];
+          if (!block.blockType)
+            continue;
+          const blockTableName = `${collection}_${toSnakeCase(key)}_${block.blockType}`.toLowerCase();
+          const bId = block.id || crypto.randomUUID();
+          const blockConfig = fieldDef?.blocks?.find((b) => b.slug === block.blockType);
+          const blockJsonFields = blockConfig?.fields.filter((f) => ["richtext", "json", "file"].includes(f.type)).map((f) => f.name) || [];
+          const blockFlatData = flattenPayload({ ...block, id: bId }, "", blockJsonFields);
+          for (const f of blockJsonFields) {
+            if (blockFlatData[f] && typeof blockFlatData[f] === "object") {
+              blockFlatData[f] = JSON.stringify(blockFlatData[f]);
+            }
+          }
+          delete blockFlatData.blockType;
+          const coercedBlockData = await this.coerceData(blockTableName, {
+            ...blockFlatData,
+            _parent_id: current.id,
+            _order: i,
+            block_type: block.blockType
+          });
+          await tx.insertInto(blockTableName).values(coercedBlockData).execute();
+        }
+      }
+      return this.findOne(collection, { id: current.id }, tx);
+    });
+  }
+  async delete(collection, query) {
+    let normalizedQuery = query;
+    if (typeof query !== "object" || query === null) {
+      normalizedQuery = { id: query };
+    }
+    const current = await this.findOne(collection, normalizedQuery);
+    if (!current)
+      return false;
+    await this._db.transaction().execute(async (tx) => {
+      const colDef = this._collections.find((c) => c.slug === collection);
+      if (colDef) {
+        for (const field of colDef.fields) {
+          const snakeName = toSnakeCase(field.name);
+          if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+            const joinTableName = `${collection}_${snakeName}_relations`.toLowerCase();
+            try {
+              await tx.deleteFrom(joinTableName).where("source_id", "=", current.id).execute();
+            } catch (e) {}
+          } else if (field.type === "blocks" && field.blocks) {
+            for (const b of field.blocks) {
+              const blockTableName = `${collection}_${snakeName}_${b.slug}`.toLowerCase();
+              try {
+                await tx.deleteFrom(blockTableName).where("_parent_id", "=", current.id).execute();
+              } catch (e) {}
+            }
+          }
+        }
+      }
+      await tx.deleteFrom(collection).where("id", "=", current.id).execute();
+    });
+    return true;
+  }
+  async updateMany(collection, query, data) {
+    return this._db.transaction().execute(async (tx) => {
+      let qb = tx.updateTable(collection);
+      if (query && Object.keys(query).length > 0) {
+        qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
+      }
+      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);
+      for (const field of jsonFields) {
+        if (flatData[field] && typeof flatData[field] === "object") {
+          flatData[field] = JSON.stringify(flatData[field]);
+        }
+      }
+      for (const key in flatData) {
+        if (Array.isArray(flatData[key])) {
+          delete flatData[key];
+        }
+      }
+      flatData.updated_at = new Date().toISOString();
+      if (Object.keys(flatData).length > 0) {
+        const coercedData = await this.coerceData(collection, flatData);
+        const result = await qb.set(coercedData).executeTakeFirst();
+        return Number(result.numUpdatedRows || 0);
+      }
+      return 0;
+    });
+  }
+  async deleteMany(collection, query) {
+    return this._db.transaction().execute(async (tx) => {
+      let selectQb = tx.selectFrom(collection).select("id");
+      if (query && Object.keys(query).length > 0) {
+        selectQb = selectQb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
+      }
+      const docs = await selectQb.execute();
+      if (docs.length === 0)
+        return 0;
+      const ids = docs.map((d) => d.id);
+      const colDef = this._collections.find((c) => c.slug === collection);
+      if (colDef) {
+        for (const field of colDef.fields) {
+          const snakeName = toSnakeCase(field.name);
+          if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+            const joinTableName = `${collection}_${snakeName}_relations`.toLowerCase();
+            try {
+              await tx.deleteFrom(joinTableName).where("source_id", "in", ids).execute();
+            } catch (e) {}
+          } else if (field.type === "blocks" && field.blocks) {
+            for (const b of field.blocks) {
+              const blockTableName = `${collection}_${snakeName}_${b.slug}`.toLowerCase();
+              try {
+                await tx.deleteFrom(blockTableName).where("_parent_id", "in", ids).execute();
+              } catch (e) {}
+            }
+          }
+        }
+      }
+      const result = await tx.deleteFrom(collection).where("id", "in", ids).executeTakeFirst();
+      return Number(result.numDeletedRows || 0);
+    });
+  }
+  async findGlobal(slug) {
+    const row = await this._db.selectFrom(slug).selectAll().limit(1).executeTakeFirst();
+    return row ? unflattenRow(row) : null;
+  }
+  async updateGlobal(slug, data) {
+    const existing = await this.findGlobal(slug);
+    const flatData = flattenPayload(data);
+    flatData.updated_at = new Date().toISOString();
+    if (!existing) {
+      if (!flatData.id)
+        flatData.id = "global";
+      await this._db.insertInto(slug).values(flatData).execute();
+    } else {
+      await this._db.updateTable(slug).set(flatData).where("id", "=", existing.id).execute();
+    }
+    return this.findGlobal(slug);
+  }
+  async runMigrations() {
+    const migrator = new Migrator({
+      db: this._db,
+      provider: new FileMigrationProvider({
+        fs,
+        path,
+        migrationFolder: path.resolve(process.cwd(), this.migrationDir)
+      })
+    });
+    const { error, results } = await migrator.migrateToLatest();
+    results?.forEach((it) => {
+      if (it.status === "Success") {
+        logger.success(`\uD83D\uDE80 Migration "${it.migrationName}" was executed successfully`);
+      } else if (it.status === "Error") {
+        logger.error(`❌ Migration "${it.migrationName}" failed`);
+      }
+    });
+    if (error) {
+      throw error;
+    }
+  }
+  async migrate(collections, globals = []) {
+    this._collections = collections;
+    if (this.push) {
+      await pushSchema(this._db, "sqlite", collections, globals, {
+        pushDestructive: this.pushDestructive
+      });
+    }
+  }
+}
+function createBetterSQLiteAdapter(path2, options) {
+  return new BetterSQLiteAdapter(path2, options);
+}
+
+export { BetterSQLiteAdapter, createBetterSQLiteAdapter };

package/dist/{chunk-dmhhf96k.js → chunk-n8aekdnr.js}

@@ -19,8 +19,11 @@ import {
 // src/db/sqlite.ts
 import fs from "node:fs/promises";
 import path from "node:path";
-import Database from "better-sqlite3";
+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 {
   name = "sqlite";
   _rawDb;

package/dist/db/better-sqlite.js

@@ -0,0 +1,14 @@
+import {
+  BetterSQLiteAdapter,
+  createBetterSQLiteAdapter
+} from "../chunk-eqtsfyjf.js";
+import"../chunk-6ew02s0c.js";
+import"../chunk-s8mqwnm1.js";
+import"../chunk-62ev8gnc.js";
+import"../chunk-cvdd4eqh.js";
+import"../chunk-ybbbqj63.js";
+import"../chunk-8sqjbsgt.js";
+export {
+  createBetterSQLiteAdapter,
+  BetterSQLiteAdapter
+};

package/dist/db/index.js

@@ -2,6 +2,10 @@ import {
   BunSQLiteAdapter,
   createBunSQLiteAdapter
 } from "../chunk-gjjcc4hm.js";
+import {
+  BetterSQLiteAdapter,
+  createBetterSQLiteAdapter
+} from "../chunk-eqtsfyjf.js";
 import {
   D1Adapter,
   createD1Adapter
@@ -13,501 +17,15 @@ import {
 import {
   SQLiteAdapter,
   createSQLiteAdapter
-} from "../chunk-dmhhf96k.js";
-import {
-  buildKyselyWhere,
-  flattenPayload,
-  pushSchema,
-  unflattenRow
-} from "../chunk-6ew02s0c.js";
+} from "../chunk-n8aekdnr.js";
+import"../chunk-6ew02s0c.js";
 import {
   BaseDatabaseAdapter
 } from "../chunk-s8mqwnm1.js";
-import {
-  logger
-} from "../chunk-62ev8gnc.js";
-import {
-  flattenFields,
-  toSnakeCase
-} from "../chunk-cvdd4eqh.js";
+import"../chunk-62ev8gnc.js";
+import"../chunk-cvdd4eqh.js";
 import"../chunk-ybbbqj63.js";
-import {
-  __require
-} from "../chunk-8sqjbsgt.js";
-// src/db/better-sqlite.ts
-import fs from "node:fs/promises";
-import path from "node:path";
-import Database from "better-sqlite3";
-import { CompiledQuery, FileMigrationProvider, Kysely, Migrator, SqliteDialect } from "kysely";
-class BetterSQLiteAdapter extends BaseDatabaseAdapter {
-  name = "better-sqlite3";
-  _rawDb;
-  _db;
-  _collections = [];
-  push;
-  migrationDir;
-  pushDestructive;
-  get raw() {
-    return this._rawDb;
-  }
-  get db() {
-    return this._db;
-  }
-  constructor(path2, options) {
-    super();
-    this._rawDb = new Database(path2);
-    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();
-  }
-  async unsafe(query, params) {
-    const compiled = CompiledQuery.raw(query, params || []);
-    const result = await this._db.executeQuery(compiled);
-    return result.rows;
-  }
-  async coerceData(collection, data) {
-    const colDef = this._collections.find((c) => c.slug === collection);
-    if (!colDef)
-      return data;
-    const result = { ...data };
-    const { flattenFields: flattenFields2 } = await import("../chunk-xg35h5a3.js");
-    const allFields = flattenFields2(colDef.fields);
-    for (const field of allFields) {
-      const colName = toSnakeCase(field.name);
-      if (!(colName in result))
-        continue;
-      const value = result[colName];
-      if (value === undefined || value === null)
-        continue;
-      switch (field.type) {
-        case "boolean":
-          result[colName] = value ? 1 : 0;
-          break;
-        case "number":
-          result[colName] = Number(value);
-          break;
-        case "date":
-          if (value instanceof Date) {
-            result[colName] = value.toISOString();
-          } else if (typeof value === "string") {
-            result[colName] = new Date(value).toISOString();
-          }
-          break;
-        case "richtext":
-        case "json":
-        case "file":
-          if (typeof value === "object") {
-            result[colName] = JSON.stringify(value);
-          }
-          break;
-      }
-    }
-    return result;
-  }
-  async count(collection, query) {
-    let qb = this._db.selectFrom(collection).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));
-    }
-    const result = await qb.executeTakeFirst();
-    return Number(result?.count || 0);
-  }
-  async create(collection, data) {
-    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);
-      for (const field of jsonFields) {
-        if (flatData[field] && typeof flatData[field] === "object") {
-          flatData[field] = JSON.stringify(flatData[field]);
-        }
-      }
-      const hasManyData = {};
-      const blocksData = {};
-      for (const key in flatData) {
-        if (Array.isArray(flatData[key])) {
-          const isHasMany = colDef?.fields.some((f) => f.type === "relationship" && ("hasMany" in f) && f.hasMany && f.name === key);
-          if (isHasMany) {
-            hasManyData[key] = flatData[key];
-          } else {
-            blocksData[key] = flatData[key];
-          }
-          delete flatData[key];
-        }
-      }
-      if (!flatData.id)
-        flatData.id = crypto.randomUUID();
-      const dbFields = flattenFields(colDef?.fields || []);
-      const validCols = new Set(dbFields.map((f) => toSnakeCase(f.name)));
-      validCols.add("id");
-      const ts = colDef?.timestamps !== false;
-      if (ts) {
-        const config = typeof colDef?.timestamps === "object" ? colDef.timestamps : {};
-        validCols.add(toSnakeCase(config.createdAt || "createdAt"));
-        validCols.add(toSnakeCase(config.updatedAt || "updatedAt"));
-      }
-      const filteredData = {};
-      for (const col of Object.keys(flatData)) {
-        if (validCols.has(col)) {
-          filteredData[col] = flatData[col];
-        }
-      }
-      const coercedData = await this.coerceData(collection, filteredData);
-      await tx.insertInto(collection).values(coercedData).execute();
-      for (const [key, values] of Object.entries(hasManyData)) {
-        const joinTableName = `${collection}_${toSnakeCase(key)}_relations`.toLowerCase();
-        if (values.length > 0) {
-          const joinData = values.map((val, idx) => {
-            const tId = typeof val === "object" ? val.id : val;
-            return { id: crypto.randomUUID(), source_id: flatData.id, target_id: tId, order: idx };
-          });
-          await tx.insertInto(joinTableName).values(joinData).execute();
-        }
-      }
-      for (const [key, blocks] of Object.entries(blocksData)) {
-        for (let i = 0;i < blocks.length; i++) {
-          const block = blocks[i];
-          if (!block.blockType)
-            continue;
-          const blockTableName = `${collection}_${toSnakeCase(key)}_${block.blockType}`.toLowerCase();
-          const bId = block.id || crypto.randomUUID();
-          const blockDef = colDef?.fields.find((f) => f.name === key && f.type === "blocks");
-          const blockConfig = blockDef?.blocks?.find((b) => b.slug === block.blockType);
-          const blockJsonFields = blockConfig?.fields.filter((f) => ["richtext", "json", "file"].includes(f.type)).map((f) => f.name) || [];
-          const blockFlatData = flattenPayload({ ...block, id: bId }, "", blockJsonFields);
-          for (const f of blockJsonFields) {
-            if (blockFlatData[f] && typeof blockFlatData[f] === "object") {
-              blockFlatData[f] = JSON.stringify(blockFlatData[f]);
-            }
-          }
-          delete blockFlatData.blockType;
-          const coercedBlockData = await this.coerceData(blockTableName, {
-            ...blockFlatData,
-            _parent_id: flatData.id,
-            _order: i,
-            block_type: block.blockType
-          });
-          await tx.insertInto(blockTableName).values(coercedBlockData).execute();
-        }
-      }
-      return this.findOne(collection, { id: flatData.id }, tx);
-    });
-  }
-  async findOne(collection, query, tx) {
-    const executor = tx || this._db;
-    let qb = executor.selectFrom(collection).selectAll();
-    if (query && Object.keys(query).length > 0) {
-      qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
-    }
-    const row = await qb.executeTakeFirst();
-    if (!row)
-      return null;
-    const unflattened = unflattenRow(row);
-    const colDef = this._collections.find((c) => c.slug === collection);
-    if (colDef) {
-      const { getRelationalFields, toSnakeCase: toSnakeCase2 } = await import("../chunk-xg35h5a3.js");
-      const relationalFields = getRelationalFields(colDef.fields);
-      for (const field of relationalFields) {
-        if (!field.name)
-          continue;
-        const snakeName = toSnakeCase2(field.name);
-        if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
-          const joinTableName = `${collection}_${snakeName}_relations`.toLowerCase();
-          try {
-            const relations = await executor.selectFrom(joinTableName).selectAll().where("source_id", "=", row.id).orderBy("order", "asc").execute();
-            unflattened[field.name] = relations.map((r) => r.target_id);
-          } catch (e) {}
-        } else if (field.type === "blocks" && field.blocks) {
-          const blockData = [];
-          for (const b of field.blocks) {
-            const blockTableName = `${collection}_${snakeName}_${b.slug}`.toLowerCase();
-            try {
-              const blocks = await executor.selectFrom(blockTableName).selectAll().where("_parent_id", "=", row.id).execute();
-              for (const blk of blocks) {
-                const uf = unflattenRow(blk);
-                uf.blockType = blk.block_type;
-                blockData.push(uf);
-              }
-            } catch (e) {}
-          }
-          blockData.sort((a, b) => a._order - b._order);
-          blockData.forEach((b) => {
-            delete b._order;
-            delete b._parent_id;
-          });
-          unflattened[field.name] = blockData;
-        }
-      }
-    }
-    return unflattened;
-  }
-  async find(collection, query, options) {
-    const page = options?.page || 1;
-    const limit = options?.limit || 10;
-    const offset = (page - 1) * limit;
-    const total = await this.count(collection, query);
-    let qb = this._db.selectFrom(collection).selectAll().limit(limit).offset(offset);
-    if (query && Object.keys(query).length > 0) {
-      qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
-    }
-    if (options?.sort) {
-      const isDesc = options.sort.startsWith("-");
-      const col = isDesc ? options.sort.substring(1) : options.sort;
-      qb = qb.orderBy(col, isDesc ? "desc" : "asc");
-    } else {
-      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 })));
-    const totalPages = Math.ceil(total / limit);
-    return {
-      docs: docs.filter(Boolean),
-      totalDocs: total,
-      limit,
-      totalPages,
-      page,
-      pagingCounter: offset + 1,
-      hasNextPage: page * limit < total,
-      hasPrevPage: page > 1,
-      prevPage: page > 1 ? page - 1 : null,
-      nextPage: page < totalPages ? page + 1 : null
-    };
-  }
-  async update(collection, query, data) {
-    return this._db.transaction().execute(async (tx) => {
-      let normalizedQuery = query;
-      if (typeof query !== "object" || query === null) {
-        normalizedQuery = { id: query };
-      }
-      const current = await this.findOne(collection, normalizedQuery, tx);
-      if (!current)
-        throw new Error("Document not found");
-      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);
-      for (const field of jsonFields) {
-        if (flatData[field] && typeof flatData[field] === "object") {
-          flatData[field] = JSON.stringify(flatData[field]);
-        }
-      }
-      const hasManyData = {};
-      const blocksData = {};
-      for (const key in flatData) {
-        if (Array.isArray(flatData[key])) {
-          const isHasMany = colDef?.fields.some((f) => f.type === "relationship" && ("hasMany" in f) && f.hasMany && f.name === key);
-          if (isHasMany) {
-            hasManyData[key] = flatData[key];
-          } else {
-            blocksData[key] = flatData[key];
-          }
-          delete flatData[key];
-        }
-      }
-      flatData.updated_at = new Date().toISOString();
-      if (Object.keys(flatData).length > 0) {
-        const coercedData = await this.coerceData(collection, flatData);
-        await tx.updateTable(collection).set(coercedData).where("id", "=", current.id).execute();
-      }
-      for (const [key, values] of Object.entries(hasManyData)) {
-        const joinTableName = `${collection}_${toSnakeCase(key)}_relations`.toLowerCase();
-        await tx.deleteFrom(joinTableName).where("source_id", "=", current.id).execute();
-        if (values.length > 0) {
-          const joinData = values.map((val, idx) => {
-            const tId = typeof val === "object" ? val.id : val;
-            return { id: crypto.randomUUID(), source_id: current.id, target_id: tId, order: idx };
-          });
-          await tx.insertInto(joinTableName).values(joinData).execute();
-        }
-      }
-      for (const [key, blocks] of Object.entries(blocksData)) {
-        const fieldDef = colDef?.fields.find((f) => f.name === key);
-        if (fieldDef?.type === "blocks" && fieldDef.blocks) {
-          for (const b of fieldDef.blocks) {
-            const blockTableName = `${collection}_${toSnakeCase(key)}_${b.slug}`.toLowerCase();
-            try {
-              await tx.deleteFrom(blockTableName).where("_parent_id", "=", current.id).execute();
-            } catch (e) {}
-          }
-        }
-        for (let i = 0;i < blocks.length; i++) {
-          const block = blocks[i];
-          if (!block.blockType)
-            continue;
-          const blockTableName = `${collection}_${toSnakeCase(key)}_${block.blockType}`.toLowerCase();
-          const bId = block.id || crypto.randomUUID();
-          const blockConfig = fieldDef?.blocks?.find((b) => b.slug === block.blockType);
-          const blockJsonFields = blockConfig?.fields.filter((f) => ["richtext", "json", "file"].includes(f.type)).map((f) => f.name) || [];
-          const blockFlatData = flattenPayload({ ...block, id: bId }, "", blockJsonFields);
-          for (const f of blockJsonFields) {
-            if (blockFlatData[f] && typeof blockFlatData[f] === "object") {
-              blockFlatData[f] = JSON.stringify(blockFlatData[f]);
-            }
-          }
-          delete blockFlatData.blockType;
-          const coercedBlockData = await this.coerceData(blockTableName, {
-            ...blockFlatData,
-            _parent_id: current.id,
-            _order: i,
-            block_type: block.blockType
-          });
-          await tx.insertInto(blockTableName).values(coercedBlockData).execute();
-        }
-      }
-      return this.findOne(collection, { id: current.id }, tx);
-    });
-  }
-  async delete(collection, query) {
-    let normalizedQuery = query;
-    if (typeof query !== "object" || query === null) {
-      normalizedQuery = { id: query };
-    }
-    const current = await this.findOne(collection, normalizedQuery);
-    if (!current)
-      return false;
-    await this._db.transaction().execute(async (tx) => {
-      const colDef = this._collections.find((c) => c.slug === collection);
-      if (colDef) {
-        for (const field of colDef.fields) {
-          const snakeName = toSnakeCase(field.name);
-          if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
-            const joinTableName = `${collection}_${snakeName}_relations`.toLowerCase();
-            try {
-              await tx.deleteFrom(joinTableName).where("source_id", "=", current.id).execute();
-            } catch (e) {}
-          } else if (field.type === "blocks" && field.blocks) {
-            for (const b of field.blocks) {
-              const blockTableName = `${collection}_${snakeName}_${b.slug}`.toLowerCase();
-              try {
-                await tx.deleteFrom(blockTableName).where("_parent_id", "=", current.id).execute();
-              } catch (e) {}
-            }
-          }
-        }
-      }
-      await tx.deleteFrom(collection).where("id", "=", current.id).execute();
-    });
-    return true;
-  }
-  async updateMany(collection, query, data) {
-    return this._db.transaction().execute(async (tx) => {
-      let qb = tx.updateTable(collection);
-      if (query && Object.keys(query).length > 0) {
-        qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
-      }
-      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);
-      for (const field of jsonFields) {
-        if (flatData[field] && typeof flatData[field] === "object") {
-          flatData[field] = JSON.stringify(flatData[field]);
-        }
-      }
-      for (const key in flatData) {
-        if (Array.isArray(flatData[key])) {
-          delete flatData[key];
-        }
-      }
-      flatData.updated_at = new Date().toISOString();
-      if (Object.keys(flatData).length > 0) {
-        const coercedData = await this.coerceData(collection, flatData);
-        const result = await qb.set(coercedData).executeTakeFirst();
-        return Number(result.numUpdatedRows || 0);
-      }
-      return 0;
-    });
-  }
-  async deleteMany(collection, query) {
-    return this._db.transaction().execute(async (tx) => {
-      let selectQb = tx.selectFrom(collection).select("id");
-      if (query && Object.keys(query).length > 0) {
-        selectQb = selectQb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
-      }
-      const docs = await selectQb.execute();
-      if (docs.length === 0)
-        return 0;
-      const ids = docs.map((d) => d.id);
-      const colDef = this._collections.find((c) => c.slug === collection);
-      if (colDef) {
-        for (const field of colDef.fields) {
-          const snakeName = toSnakeCase(field.name);
-          if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
-            const joinTableName = `${collection}_${snakeName}_relations`.toLowerCase();
-            try {
-              await tx.deleteFrom(joinTableName).where("source_id", "in", ids).execute();
-            } catch (e) {}
-          } else if (field.type === "blocks" && field.blocks) {
-            for (const b of field.blocks) {
-              const blockTableName = `${collection}_${snakeName}_${b.slug}`.toLowerCase();
-              try {
-                await tx.deleteFrom(blockTableName).where("_parent_id", "in", ids).execute();
-              } catch (e) {}
-            }
-          }
-        }
-      }
-      const result = await tx.deleteFrom(collection).where("id", "in", ids).executeTakeFirst();
-      return Number(result.numDeletedRows || 0);
-    });
-  }
-  async findGlobal(slug) {
-    const row = await this._db.selectFrom(slug).selectAll().limit(1).executeTakeFirst();
-    return row ? unflattenRow(row) : null;
-  }
-  async updateGlobal(slug, data) {
-    const existing = await this.findGlobal(slug);
-    const flatData = flattenPayload(data);
-    flatData.updated_at = new Date().toISOString();
-    if (!existing) {
-      if (!flatData.id)
-        flatData.id = "global";
-      await this._db.insertInto(slug).values(flatData).execute();
-    } else {
-      await this._db.updateTable(slug).set(flatData).where("id", "=", existing.id).execute();
-    }
-    return this.findGlobal(slug);
-  }
-  async runMigrations() {
-    const migrator = new Migrator({
-      db: this._db,
-      provider: new FileMigrationProvider({
-        fs,
-        path,
-        migrationFolder: path.resolve(process.cwd(), this.migrationDir)
-      })
-    });
-    const { error, results } = await migrator.migrateToLatest();
-    results?.forEach((it) => {
-      if (it.status === "Success") {
-        logger.success(`\uD83D\uDE80 Migration "${it.migrationName}" was executed successfully`);
-      } else if (it.status === "Error") {
-        logger.error(`❌ Migration "${it.migrationName}" failed`);
-      }
-    });
-    if (error) {
-      throw error;
-    }
-  }
-  async migrate(collections, globals = []) {
-    this._collections = collections;
-    if (this.push) {
-      await pushSchema(this._db, "sqlite", collections, globals, {
-        pushDestructive: this.pushDestructive
-      });
-    }
-  }
-}
-function createBetterSQLiteAdapter(path2, options) {
-  return new BetterSQLiteAdapter(path2, options);
-}
+import"../chunk-8sqjbsgt.js";
 export {
   createSQLiteAdapter,
   createPostgresAdapter,

package/dist/db/sqlite.js

@@ -1,7 +1,7 @@
 import {
   SQLiteAdapter,
   createSQLiteAdapter
-} from "../chunk-dmhhf96k.js";
+} from "../chunk-n8aekdnr.js";
 import"../chunk-6ew02s0c.js";
 import"../chunk-s8mqwnm1.js";
 import"../chunk-62ev8gnc.js";

package/dist/runtimes/bun.js

@@ -1,6 +1,6 @@
 import {
   createAPIRouter
-} from "../chunk-hmhcense.js";
+} from "../chunk-0nf7fe26.js";
 import"../chunk-dy5t83hr.js";
 import"../chunk-62ev8gnc.js";
 import"../chunk-cvdd4eqh.js";

package/dist/runtimes/cloudflare-workers.js

@@ -1,6 +1,6 @@
 import {
   createAPIRouter
-} from "../chunk-hmhcense.js";
+} from "../chunk-0nf7fe26.js";
 import"../chunk-dy5t83hr.js";
 import"../chunk-62ev8gnc.js";
 import"../chunk-cvdd4eqh.js";

package/dist/runtimes/next.js

@@ -1,6 +1,6 @@
 import {
   createAPIRouter
-} from "../chunk-hmhcense.js";
+} from "../chunk-0nf7fe26.js";
 import"../chunk-dy5t83hr.js";
 import"../chunk-62ev8gnc.js";
 import"../chunk-cvdd4eqh.js";

package/dist/runtimes/node.js

@@ -1,6 +1,6 @@
 import {
   createAPIRouter
-} from "../chunk-hmhcense.js";
+} from "../chunk-0nf7fe26.js";
 import"../chunk-dy5t83hr.js";
 import"../chunk-62ev8gnc.js";
 import"../chunk-cvdd4eqh.js";

package/dist/server/middlewares/rate-limit.d.ts

@@ -1,3 +1,3 @@
 import type { MiddlewareHandler } from "hono";
-import type { OpacaConfig } from "../../types";
+import type { OpacaConfig } from "@/types";
 export declare function createRateLimitMiddleware(config: OpacaConfig): MiddlewareHandler;

package/dist/server.js

@@ -4,7 +4,7 @@ import {
   createGlobalHandlers,
   createHandlers,
   hydrateDoc
-} from "./chunk-hmhcense.js";
+} from "./chunk-0nf7fe26.js";
 import {
   defineConfig
 } from "./chunk-zvwb67nd.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opacacms",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "scripts": {
     "build": "bun run ../../scripts/build.ts && tsc --emitDeclarationOnly",
     "build:publish": "bun run ../../scripts/build.ts --publish && tsc --emitDeclarationOnly",

package/src/db/better-sqlite.ts

@@ -1,6 +1,8 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import Database from "better-sqlite3";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const Database = require("better-sqlite3");
 import { CompiledQuery, FileMigrationProvider, Kysely, Migrator, SqliteDialect, sql } from "kysely";
 import type { Collection, FindOptions, Global, PaginatedResult } from "../types";
 import { logger } from "../utils/logger";
@@ -251,7 +253,7 @@ export class BetterSQLiteAdapter extends BaseDatabaseAdapter {
               .orderBy("order", "asc")
               .execute();
             unflattened[field.name!] = relations.map((r: any) => r.target_id);
-          } catch (e) {}
+          } catch (e) { }
         } else if (field.type === "blocks" && field.blocks) {
           const blockData: any[] = [];
           for (const b of field.blocks) {
@@ -268,7 +270,7 @@ export class BetterSQLiteAdapter extends BaseDatabaseAdapter {
                 uf.blockType = blk.block_type;
                 blockData.push(uf);
               }
-            } catch (e) {}
+            } catch (e) { }
           }
           blockData.sort((a: any, b: any) => a._order - b._order);
           blockData.forEach((b: any) => {
@@ -399,7 +401,7 @@ export class BetterSQLiteAdapter extends BaseDatabaseAdapter {
             const blockTableName = `${collection}_${toSnakeCase(key)}_${b.slug}`.toLowerCase();
             try {
               await tx.deleteFrom(blockTableName).where("_parent_id", "=", current.id).execute();
-            } catch (e) {}
+            } catch (e) { }
           }
         }
 
@@ -462,13 +464,13 @@ export class BetterSQLiteAdapter extends BaseDatabaseAdapter {
             const joinTableName = `${collection}_${snakeName}_relations`.toLowerCase();
             try {
               await tx.deleteFrom(joinTableName).where("source_id", "=", current.id).execute();
-            } catch (e) {}
+            } catch (e) { }
           } else if (field.type === "blocks" && field.blocks) {
             for (const b of field.blocks) {
               const blockTableName = `${collection}_${snakeName}_${b.slug}`.toLowerCase();
               try {
                 await tx.deleteFrom(blockTableName).where("_parent_id", "=", current.id).execute();
-              } catch (e) {}
+              } catch (e) { }
             }
           }
         }
@@ -540,13 +542,13 @@ export class BetterSQLiteAdapter extends BaseDatabaseAdapter {
             const joinTableName = `${collection}_${snakeName}_relations`.toLowerCase();
             try {
               await tx.deleteFrom(joinTableName).where("source_id", "in", ids).execute();
-            } catch (e) {}
+            } catch (e) { }
           } else if (field.type === "blocks" && field.blocks) {
             for (const b of field.blocks) {
               const blockTableName = `${collection}_${snakeName}_${b.slug}`.toLowerCase();
               try {
                 await tx.deleteFrom(blockTableName).where("_parent_id", "in", ids).execute();
-              } catch (e) {}
+              } catch (e) { }
             }
           }
         }

package/src/db/sqlite.ts

@@ -1,6 +1,8 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import Database from "better-sqlite3";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const Database = require("better-sqlite3");
 import { CompiledQuery, FileMigrationProvider, Kysely, Migrator, SqliteDialect, sql } from "kysely";
 import type { Collection, FindOptions, Global, PaginatedResult } from "../types";
 import { logger } from "../utils/logger";
@@ -253,7 +255,7 @@ export class SQLiteAdapter extends BaseDatabaseAdapter {
               current = current[parts[i]!];
             }
             current[parts[parts.length - 1]!] = relations.map((r: any) => r.target_id);
-          } catch (e) {}
+          } catch (e) { }
         } else if (field.type === "blocks" && field.blocks) {
           const blockData: any[] = [];
           for (const b of field.blocks) {
@@ -271,7 +273,7 @@ export class SQLiteAdapter extends BaseDatabaseAdapter {
                 uf.blockType = blk.block_type;
                 blockData.push(uf);
               }
-            } catch (e) {}
+            } catch (e) { }
           }
           blockData.sort((a: any, b: any) => a._order - b._order);
           blockData.forEach((b: any) => {
@@ -408,7 +410,7 @@ export class SQLiteAdapter extends BaseDatabaseAdapter {
               `${collection}_${toSnakeCase(key)}_${toSnakeCase(b.slug)}`.toLowerCase();
             try {
               await tx.deleteFrom(blockTableName).where("_parent_id", "=", current.id).execute();
-            } catch (e) {}
+            } catch (e) { }
           }
         }
 
@@ -473,14 +475,14 @@ export class SQLiteAdapter extends BaseDatabaseAdapter {
             const joinTableName = `${collection}_${snakeName}_relations`.toLowerCase();
             try {
               await tx.deleteFrom(joinTableName).where("source_id", "=", current.id).execute();
-            } catch (e) {}
+            } catch (e) { }
           } else if (field.type === "blocks" && field.blocks) {
             for (const b of field.blocks) {
               const blockTableName =
                 `${collection}_${snakeName}_${toSnakeCase(b.slug)}`.toLowerCase();
               try {
                 await tx.deleteFrom(blockTableName).where("_parent_id", "=", current.id).execute();
-              } catch (e) {}
+              } catch (e) { }
             }
           }
         }
@@ -553,14 +555,14 @@ export class SQLiteAdapter extends BaseDatabaseAdapter {
             const joinTableName = `${collection}_${snakeName}_relations`.toLowerCase();
             try {
               await tx.deleteFrom(joinTableName).where("source_id", "in", ids).execute();
-            } catch (e) {}
+            } catch (e) { }
           } else if (field.type === "blocks" && field.blocks) {
             for (const b of field.blocks) {
               const blockTableName =
                 `${collection}_${snakeName}_${toSnakeCase(b.slug)}`.toLowerCase();
               try {
                 await tx.deleteFrom(blockTableName).where("_parent_id", "in", ids).execute();
-              } catch (e) {}
+              } catch (e) { }
             }
           }
         }

package/src/schema/index.ts

@@ -2,4 +2,3 @@ export { Collection, CollectionBuilder } from "./collection";
 export { Field, FieldBuilder } from "./fields/index";
 export { Global, GlobalBuilder } from "./global";
 export type { AccessRules, InferFields } from "./infer";
-

package/src/server/middlewares/rate-limit.ts

@@ -1,7 +1,8 @@
-import { WorkersKVStore } from "@hono-rate-limiter/cloudflare";
+
 import type { Context, MiddlewareHandler } from "hono";
 import { rateLimiter } from "hono-rate-limiter";
-import type { OpacaConfig } from "../../types";
+import type { OpacaConfig } from "@/types";
+import { logger } from "@/utils/logger";
 
 export function createRateLimitMiddleware(config: OpacaConfig): MiddlewareHandler {
   const rateLimitConfig = config.api?.rateLimit;
@@ -50,7 +51,12 @@ export function createRateLimitMiddleware(config: OpacaConfig): MiddlewareHandle
       );
 
       if (kvBindingKey) {
-        resolvedStore = new WorkersKVStore({ namespace: (c.env as any)[kvBindingKey] });
+        try {
+          const { WorkersKVStore } = await import("@hono-rate-limiter/cloudflare");
+          resolvedStore = new WorkersKVStore({ namespace: (c.env as any)[kvBindingKey] });
+        } catch (e) {
+          logger.error("Failed to load @hono-rate-limiter/cloudflare dynamic import. Make sure you are in a Cloudflare environment.", e);
+        }
       }
     }