opacacms 0.1.0

package/dist/src/db/sqlite.js

@@ -0,0 +1,534 @@
+import {
+  buildKyselyWhere,
+  flattenPayload,
+  pushSchema,
+  unflattenRow
+} from "../../chunk-6ew02s0c.js";
+import {
+  BaseDatabaseAdapter
+} from "../../chunk-s8mqwnm1.js";
+import {
+  logger
+} from "../../chunk-62ev8gnc.js";
+import {
+  flattenFields,
+  getRelationalFields,
+  toSnakeCase
+} from "../../chunk-cvdd4eqh.js";
+import"../../chunk-ybbbqj63.js";
+import"../../chunk-8sqjbsgt.js";
+
+// src/db/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 SQLiteAdapter extends BaseDatabaseAdapter {
+  name = "sqlite";
+  _rawDb;
+  _db;
+  _collections = [];
+  _globals = [];
+  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 allFields = flattenFields(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) => f.name && (["richtext", "json", "file"].includes(f.type) || f.localized)).map((f) => f.name) || [];
+      const flatData = flattenPayload(data, "", jsonFields);
+      const relationalFields = getRelationalFields(colDef?.fields || []);
+      const hasManyData = {};
+      const blocksData = {};
+      for (const field of relationalFields) {
+        const key = field.name;
+        if (Array.isArray(flatData[key])) {
+          if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+            hasManyData[key] = flatData[key];
+          } else if (field.type === "blocks") {
+            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 : {};
+        const updatedField = toSnakeCase(config.updatedAt || "updatedAt");
+        const createdField = toSnakeCase(config.createdAt || "createdAt");
+        validCols.add(createdField);
+        validCols.add(updatedField);
+        if (!flatData[createdField])
+          flatData[createdField] = new Date().toISOString();
+        if (!flatData[updatedField])
+          flatData[updatedField] = new Date().toISOString();
+      }
+      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)}_${toSnakeCase(block.blockType)}`.toLowerCase();
+          const bId = block.id || crypto.randomUUID();
+          const blockDef = relationalFields.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 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 = `${collection}_${snakeName}_relations`.toLowerCase();
+          try {
+            const relations = await executor.selectFrom(joinTableName).selectAll().where("source_id", "=", row.id).orderBy("order", "asc").execute();
+            const parts = field.name.split("__");
+            let current = unflattened;
+            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]] = 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}_${toSnakeCase(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;
+          });
+          const parts = field.name.split("__");
+          let current = unflattened;
+          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;
+        }
+      }
+    }
+    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 [col, dir] = (options.sort ?? "").split(":");
+      if (col) {
+        qb = qb.orderBy(col, dir === "desc" ? "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) => f.name && (["richtext", "json", "file"].includes(f.type) || f.localized)).map((f) => f.name) || [];
+      const flatData = flattenPayload(data, "", jsonFields);
+      const relationalFields = getRelationalFields(colDef?.fields || []);
+      const hasManyData = {};
+      const blocksData = {};
+      for (const field of relationalFields) {
+        const key = field.name;
+        if (Array.isArray(flatData[key])) {
+          if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+            hasManyData[key] = flatData[key];
+          } else if (field.type === "blocks") {
+            blocksData[key] = flatData[key];
+          }
+          delete flatData[key];
+        }
+      }
+      const ts = colDef?.timestamps !== false;
+      if (ts) {
+        const config = typeof colDef?.timestamps === "object" ? colDef.timestamps : {};
+        const updatedField = toSnakeCase(config.updatedAt || "updatedAt");
+        flatData[updatedField] = 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 = relationalFields.find((f) => f.name === key && f.type === "blocks");
+        if (fieldDef?.type === "blocks" && fieldDef.blocks) {
+          for (const b of fieldDef.blocks) {
+            const blockTableName = `${collection}_${toSnakeCase(key)}_${toSnakeCase(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)}_${toSnakeCase(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) {
+        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 = `${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}_${toSnakeCase(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) => f.name && (["richtext", "json", "file"].includes(f.type) || f.localized)).map((f) => f.name) || [];
+      const flatData = flattenPayload(data, "", jsonFields);
+      for (const key in flatData) {
+        if (Array.isArray(flatData[key])) {
+          delete flatData[key];
+        }
+      }
+      const ts = colDef?.timestamps !== false;
+      if (ts) {
+        const config = typeof colDef?.timestamps === "object" ? colDef.timestamps : {};
+        const updatedField = toSnakeCase(config.updatedAt || "updatedAt");
+        flatData[updatedField] = 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) {
+        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 = `${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}_${toSnakeCase(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);
+    const globalDef = this._globals.find((g) => g.slug === slug);
+    const ts = globalDef?.timestamps !== false;
+    if (ts) {
+      const config = typeof globalDef?.timestamps === "object" ? globalDef.timestamps : {};
+      const updatedField = toSnakeCase(config.updatedAt || "updatedAt");
+      flatData[updatedField] = new Date().toISOString();
+    }
+    if (!existing) {
+      if (!flatData.id)
+        flatData.id = "global";
+      if (ts) {
+        const config = typeof globalDef?.timestamps === "object" ? globalDef.timestamps : {};
+        const createdField = toSnakeCase(config.createdAt || "createdAt");
+        if (!flatData[createdField])
+          flatData[createdField] = flatData[toSnakeCase(config.updatedAt || "updatedAt")];
+      }
+      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;
+    this._globals = globals;
+    if (this.push) {
+      await pushSchema(this._db, "sqlite", collections, globals, {
+        pushDestructive: this.pushDestructive
+      });
+    }
+  }
+}
+function createSQLiteAdapter(path2, options) {
+  return new SQLiteAdapter(path2, options);
+}
+export {
+  createSQLiteAdapter,
+  SQLiteAdapter
+};

package/dist/src/index.js

@@ -0,0 +1,20 @@
+import {
+  OpacaError,
+  createClient
+} from "../chunk-d3ffeqp9.js";
+import {
+  defineConfig
+} from "../chunk-zvwb67nd.js";
+import {
+  createAuth,
+  sanitizeConfig
+} from "../chunk-dy5t83hr.js";
+import"../chunk-ybbbqj63.js";
+import"../chunk-8sqjbsgt.js";
+export {
+  sanitizeConfig,
+  defineConfig,
+  createClient,
+  createAuth,
+  OpacaError
+};

package/dist/src/runtimes/bun.js

@@ -0,0 +1,36 @@
+import {
+  createAPIRouter
+} from "../../chunk-hmhcense.js";
+import"../../chunk-dy5t83hr.js";
+import"../../chunk-62ev8gnc.js";
+import"../../chunk-cvdd4eqh.js";
+import"../../chunk-ybbbqj63.js";
+import"../../chunk-8sqjbsgt.js";
+
+// src/runtimes/bun.ts
+import { Hono } from "hono";
+function createBunHandler(config, options) {
+  const app = new Hono;
+  const apiRouter = createAPIRouter(config);
+  app.route("/api", apiRouter);
+  const init = async () => {
+    console.log("\uD83D\uDE80 Initializing OpacaCMS (Bun runtime)...");
+    if (config.db) {
+      await config.db.connect();
+      console.log(`\uD83D\uDCE6 Database "${config.db.name}" connected`);
+      await config.db.migrate(config.collections);
+      console.log("✅ Migrations completed");
+    }
+    const port = options?.port || 3000;
+    Bun.serve({
+      fetch: app.fetch,
+      port
+    });
+    console.log(`Listening on http://localhost:${port}`);
+    return app;
+  };
+  return { app, init };
+}
+export {
+  createBunHandler
+};

package/dist/src/runtimes/cloudflare-workers.js

@@ -0,0 +1,29 @@
+import {
+  createAPIRouter
+} from "../../chunk-hmhcense.js";
+import"../../chunk-dy5t83hr.js";
+import"../../chunk-62ev8gnc.js";
+import"../../chunk-cvdd4eqh.js";
+import"../../chunk-ybbbqj63.js";
+import"../../chunk-8sqjbsgt.js";
+
+// src/runtimes/cloudflare-workers.ts
+import { Hono } from "hono";
+var cachedApp;
+function createCloudflareWorkersHandler(configOrFactory) {
+  const app = new Hono;
+  app.use("/api/*", async (c, next) => {
+    if (cachedApp)
+      return cachedApp.fetch(c.req.raw, c.env, c.executionCtx);
+    const config = typeof configOrFactory === "function" ? await configOrFactory(c.env, c.req.raw) : configOrFactory;
+    const apiRouter = createAPIRouter(config);
+    const innerApp = new Hono;
+    innerApp.route("/", apiRouter);
+    cachedApp = innerApp;
+    return cachedApp.fetch(c.req.raw, c.env, c.executionCtx);
+  });
+  return app;
+}
+export {
+  createCloudflareWorkersHandler
+};

package/dist/src/runtimes/next.js

@@ -0,0 +1,26 @@
+import {
+  createAPIRouter
+} from "../../chunk-hmhcense.js";
+import"../../chunk-dy5t83hr.js";
+import"../../chunk-62ev8gnc.js";
+import"../../chunk-cvdd4eqh.js";
+import"../../chunk-ybbbqj63.js";
+import"../../chunk-8sqjbsgt.js";
+
+// src/runtimes/next.ts
+import { handle } from "hono/vercel";
+function createNextHandler(config) {
+  const app = createAPIRouter(config);
+  const handler = handle(app);
+  return {
+    GET: handler,
+    POST: handler,
+    PUT: handler,
+    DELETE: handler,
+    PATCH: handler,
+    OPTIONS: handler
+  };
+}
+export {
+  createNextHandler
+};

package/dist/src/runtimes/node.js

@@ -0,0 +1,38 @@
+import {
+  createAPIRouter
+} from "../../chunk-hmhcense.js";
+import"../../chunk-dy5t83hr.js";
+import"../../chunk-62ev8gnc.js";
+import"../../chunk-cvdd4eqh.js";
+import"../../chunk-ybbbqj63.js";
+import"../../chunk-8sqjbsgt.js";
+
+// src/runtimes/node.ts
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+function createNodeHandler(config, options) {
+  const app = new Hono;
+  const apiRouter = createAPIRouter(config);
+  app.route("/api", apiRouter);
+  const init = async () => {
+    console.log("\uD83D\uDE80 Initializing OpacaCMS (Node.js runtime)...");
+    if (config.db) {
+      await config.db.connect();
+      console.log(`\uD83D\uDCE6 Database "${config.db.name}" connected`);
+      await config.db.migrate(config.collections);
+      console.log("✅ Migrations completed");
+    }
+    const port = options?.port || 3000;
+    serve({
+      fetch: app.fetch,
+      port
+    }, (info) => {
+      console.log(`Listening on http://localhost:${info.port}`);
+    });
+    return app;
+  };
+  return { app, init };
+}
+export {
+  createNodeHandler
+};