monapi 0.1.0 → 1.0.0

package/dist/index.js

@@ -1,9 +1,14 @@
 'use strict';
 
-var express = require('express');
 var mongoose = require('mongoose');
+var express = require('express');
 
-// src/monapi.ts
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/types/query.ts
 var FieldType = /* @__PURE__ */ ((FieldType2) => {
@@ -283,6 +288,43 @@ var BadRequestError = class _BadRequestError extends MonapiError {
   }
 };
 
+// src/core/permission-checker.ts
+var ROUTE_TO_CRUD = {
+  list: "find",
+  get: "find",
+  create: "create",
+  update: "update",
+  patch: "patch",
+  delete: "delete"
+};
+async function checkPermissions(req, collection, routeOp, permissions) {
+  if (!permissions) return;
+  const permission = permissions[routeOp];
+  if (!permission) return;
+  const user = req.user;
+  if (!user) throw new UnauthorizedError();
+  const crudOp = ROUTE_TO_CRUD[routeOp] || routeOp;
+  const allowed = await evaluatePermission(permission, {
+    user,
+    collection,
+    operation: crudOp,
+    data: req.body,
+    id: req.params.id,
+    req: req.raw
+  });
+  if (!allowed) throw new ForbiddenError();
+}
+async function evaluatePermission(permission, ctx) {
+  if (Array.isArray(permission)) {
+    if (!ctx.user.roles || ctx.user.roles.length === 0) return false;
+    return permission.some((role) => ctx.user.roles?.includes(role));
+  }
+  if (typeof permission === "function") {
+    return permission(ctx);
+  }
+  return false;
+}
+
 // src/engine/filter-parser.ts
 var OPERATOR_MAP = {
   eq: "$eq",
@@ -525,376 +567,448 @@ function extractPagination(queryParams, defaultLimit = DEFAULT_LIMIT, maxLimit =
   return { page, limit };
 }
 
-// src/engine/hook-executor.ts
-function createHookContext(params) {
-  const user = params.req.user;
+// src/core/crud-operations.ts
+function createCtx(collection, operation, req, res, extra = {}) {
   return {
-    collection: params.collection,
-    operation: params.operation,
-    user,
-    query: params.query,
-    data: params.data,
-    id: params.id,
-    result: params.result,
-    req: params.req,
-    res: params.res,
+    collection,
+    operation,
+    user: req.user,
+    query: extra.query,
+    data: extra.data,
+    id: extra.id,
+    result: extra.result,
+    req: req.raw,
+    res: res.raw,
     meta: {}
   };
 }
-async function executeHook(hooks, hookName, ctx, logger) {
-  if (!hooks) return ctx;
-  const hookFn = hooks[hookName];
-  if (!hookFn) return ctx;
+async function runHook(hooks, hookName, ctx, logger) {
+  if (!hooks) return;
+  const fn = hooks[hookName];
+  if (!fn) return;
   try {
-    await hookFn(ctx);
+    await fn(ctx);
   } catch (error) {
     if (logger) {
-      logger.error(`Hook '${hookName}' failed for collection '${ctx.collection}': ${error.message}`);
+      logger.error(`Hook '${hookName}' failed for '${ctx.collection}': ${error.message}`);
     }
     throw error;
   }
-  return ctx;
 }
-
-// src/engine/crud-handlers.ts
-function createCRUDHandlers(options) {
-  const { collectionName, model, adapter, config, defaults, logger } = options;
+async function listDocuments(req, res, opts) {
+  const { collectionName, model, adapter, config, defaults, logger } = opts;
+  const mongoQuery = buildQuery(req.query, {
+    adapter,
+    queryConfig: config.query ?? defaults?.query,
+    defaultLimit: defaults?.pagination?.limit,
+    maxLimit: defaults?.pagination?.maxLimit,
+    maxRegexLength: defaults?.security?.maxRegexLength
+  });
+  const ctx = createCtx(collectionName, "find", req, res, { query: mongoQuery });
+  await runHook(config.hooks, "beforeFind", ctx, logger);
+  if (ctx.preventDefault) return { statusCode: 0, data: null };
+  const query = ctx.query ?? mongoQuery;
+  const [docs, total] = await Promise.all([
+    model.find(query.filter).sort(query.sort).skip(query.skip ?? 0).limit(query.limit ?? 10).select(query.projection ?? {}).lean().exec(),
+    model.countDocuments(query.filter).exec()
+  ]);
+  const { page, limit } = extractPagination(
+    req.query,
+    defaults?.pagination?.limit,
+    defaults?.pagination?.maxLimit
+  );
+  ctx.result = docs;
+  await runHook(config.hooks, "afterFind", ctx, logger);
   return {
-    list: config.handlers?.list ?? createListHandler(collectionName, model, adapter, config, defaults, logger),
-    get: config.handlers?.get ?? createGetHandler(collectionName, model, adapter, config, logger),
-    create: config.handlers?.create ?? createCreateHandler(collectionName, model, adapter, config, logger),
-    update: config.handlers?.update ?? createUpdateHandler(collectionName, model, adapter, config, logger),
-    patch: config.handlers?.patch ?? createPatchHandler(collectionName, model, adapter, config, logger),
-    delete: config.handlers?.delete ?? createDeleteHandler(collectionName, model, config, logger)
+    statusCode: 200,
+    data: ctx.result ?? docs,
+    meta: buildPaginationMeta(total, page, limit)
   };
 }
-function createListHandler(collectionName, model, adapter, config, defaults, logger) {
-  return async (req, res, next) => {
-    try {
-      const mongoQuery = buildQuery(req.query, {
-        adapter,
-        queryConfig: config.query ?? defaults?.query,
-        defaultLimit: defaults?.pagination?.limit,
-        maxLimit: defaults?.pagination?.maxLimit,
-        maxRegexLength: defaults?.security?.maxRegexLength
-      });
-      const ctx = createHookContext({
-        collection: collectionName,
-        operation: "find",
-        req,
-        res,
-        query: mongoQuery
-      });
-      await executeHook(config.hooks, "beforeFind", ctx, logger);
-      if (ctx.preventDefault) {
-        return;
+async function getDocument(req, res, opts) {
+  const { collectionName, model, config, logger } = opts;
+  const { id } = req.params;
+  let projection;
+  if (req.query.fields) {
+    const fields = typeof req.query.fields === "string" ? req.query.fields.split(",") : req.query.fields;
+    projection = {};
+    for (const f of fields) {
+      const trimmed = f.trim();
+      if (trimmed && !trimmed.startsWith("$")) {
+        projection[trimmed] = 1;
       }
-      const query = ctx.query ?? mongoQuery;
-      const [docs, total] = await Promise.all([
-        model.find(query.filter).sort(query.sort).skip(query.skip ?? 0).limit(query.limit ?? 10).select(query.projection ?? {}).lean().exec(),
-        model.countDocuments(query.filter).exec()
-      ]);
-      const { page, limit } = extractPagination(req.query, defaults?.pagination?.limit, defaults?.pagination?.maxLimit);
-      ctx.result = docs;
-      await executeHook(config.hooks, "afterFind", ctx, logger);
-      const response = {
-        data: ctx.result ?? docs,
-        meta: buildPaginationMeta(total, page, limit)
-      };
-      res.json(response);
-    } catch (error) {
-      next(error);
     }
-  };
+  }
+  const ctx = createCtx(collectionName, "find", req, res, { id });
+  await runHook(config.hooks, "beforeFind", ctx, logger);
+  if (ctx.preventDefault) return { statusCode: 0, data: null };
+  let query = model.findById(id);
+  if (projection) query = query.select(projection);
+  const doc = await query.lean().exec();
+  if (!doc) throw new NotFoundError(collectionName, id);
+  ctx.result = doc;
+  await runHook(config.hooks, "afterFind", ctx, logger);
+  return { statusCode: 200, data: ctx.result ?? doc };
 }
-function createGetHandler(collectionName, model, _adapter, config, logger) {
-  return async (req, res, next) => {
-    try {
-      const { id } = req.params;
-      const fieldsParam = req.query.fields;
-      let projection;
-      if (fieldsParam) {
-        const fields = typeof fieldsParam === "string" ? fieldsParam.split(",") : fieldsParam;
-        projection = {};
-        for (const f of fields) {
-          const trimmed = f.trim();
-          if (trimmed && !trimmed.startsWith("$")) {
-            projection[trimmed] = 1;
-          }
-        }
-      }
-      const ctx = createHookContext({
-        collection: collectionName,
-        operation: "find",
-        req,
-        res,
-        id
-      });
-      await executeHook(config.hooks, "beforeFind", ctx, logger);
-      if (ctx.preventDefault) return;
-      let query = model.findById(id);
-      if (projection) query = query.select(projection);
-      const doc = await query.lean().exec();
-      if (!doc) {
-        throw new NotFoundError(collectionName, id);
-      }
-      ctx.result = doc;
-      await executeHook(config.hooks, "afterFind", ctx, logger);
-      const response = { data: ctx.result ?? doc };
-      res.json(response);
-    } catch (error) {
-      next(error);
-    }
-  };
+async function createDocument(req, res, opts) {
+  const { collectionName, model, adapter, config, logger } = opts;
+  const data = req.body;
+  const validation = await adapter.validate(data);
+  if (!validation.valid) {
+    throw new ValidationError("Validation failed", validation.errors);
+  }
+  const ctx = createCtx(collectionName, "create", req, res, { data: validation.data ?? data });
+  await runHook(config.hooks, "beforeCreate", ctx, logger);
+  if (ctx.preventDefault) return { statusCode: 0, data: null };
+  const doc = await model.create(ctx.data ?? data);
+  const result = doc.toObject();
+  ctx.result = result;
+  await runHook(config.hooks, "afterCreate", ctx, logger);
+  return { statusCode: 201, data: ctx.result ?? result };
 }
-function createCreateHandler(collectionName, model, adapter, config, logger) {
-  return async (req, res, next) => {
-    try {
-      const data = req.body;
-      const validation = await adapter.validate(data);
-      if (!validation.valid) {
-        throw new ValidationError("Validation failed", validation.errors);
-      }
-      const ctx = createHookContext({
-        collection: collectionName,
-        operation: "create",
-        req,
-        res,
-        data: validation.data ?? data
-      });
-      await executeHook(config.hooks, "beforeCreate", ctx, logger);
-      if (ctx.preventDefault) return;
-      const doc = await model.create(ctx.data ?? data);
-      const result = doc.toObject();
-      ctx.result = result;
-      await executeHook(config.hooks, "afterCreate", ctx, logger);
-      const response = { data: ctx.result ?? result };
-      res.status(201).json(response);
-    } catch (error) {
-      next(error);
-    }
-  };
+async function updateDocument(req, res, opts) {
+  const { collectionName, model, adapter, config, logger } = opts;
+  const { id } = req.params;
+  const data = req.body;
+  const validation = await adapter.validate(data);
+  if (!validation.valid) {
+    throw new ValidationError("Validation failed", validation.errors);
+  }
+  const ctx = createCtx(collectionName, "update", req, res, { id, data: validation.data ?? data });
+  await runHook(config.hooks, "beforeUpdate", ctx, logger);
+  if (ctx.preventDefault) return { statusCode: 0, data: null };
+  const doc = await model.findByIdAndUpdate(id, ctx.data ?? data, { new: true, runValidators: true, overwrite: true }).lean().exec();
+  if (!doc) throw new NotFoundError(collectionName, id);
+  ctx.result = doc;
+  await runHook(config.hooks, "afterUpdate", ctx, logger);
+  return { statusCode: 200, data: ctx.result ?? doc };
 }
-function createUpdateHandler(collectionName, model, adapter, config, logger) {
-  return async (req, res, next) => {
-    try {
-      const { id } = req.params;
-      const data = req.body;
-      const validation = await adapter.validate(data);
-      if (!validation.valid) {
-        throw new ValidationError("Validation failed", validation.errors);
-      }
-      const ctx = createHookContext({
-        collection: collectionName,
-        operation: "update",
-        req,
-        res,
-        id,
-        data: validation.data ?? data
-      });
-      await executeHook(config.hooks, "beforeUpdate", ctx, logger);
-      if (ctx.preventDefault) return;
-      const doc = await model.findByIdAndUpdate(id, ctx.data ?? data, { new: true, runValidators: true, overwrite: true }).lean().exec();
-      if (!doc) {
-        throw new NotFoundError(collectionName, id);
-      }
-      ctx.result = doc;
-      await executeHook(config.hooks, "afterUpdate", ctx, logger);
-      const response = { data: ctx.result ?? doc };
-      res.json(response);
-    } catch (error) {
-      next(error);
+async function patchDocument(req, res, opts) {
+  const { collectionName, model, config, logger } = opts;
+  const { id } = req.params;
+  const data = req.body;
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    throw new ValidationError("Request body must be an object");
+  }
+  for (const key of Object.keys(data)) {
+    if (key.startsWith("$")) {
+      throw new ValidationError(`Invalid field name: ${key}`);
     }
-  };
+  }
+  const ctx = createCtx(collectionName, "patch", req, res, { id, data });
+  await runHook(config.hooks, "beforeUpdate", ctx, logger);
+  if (ctx.preventDefault) return { statusCode: 0, data: null };
+  const doc = await model.findByIdAndUpdate(id, { $set: ctx.data ?? data }, { new: true, runValidators: true }).lean().exec();
+  if (!doc) throw new NotFoundError(collectionName, id);
+  ctx.result = doc;
+  await runHook(config.hooks, "afterUpdate", ctx, logger);
+  return { statusCode: 200, data: ctx.result ?? doc };
 }
-function createPatchHandler(collectionName, model, _adapter, config, logger) {
-  return async (req, res, next) => {
-    try {
-      const { id } = req.params;
-      const data = req.body;
-      if (typeof data !== "object" || data === null || Array.isArray(data)) {
-        throw new ValidationError("Request body must be an object");
-      }
-      for (const key of Object.keys(data)) {
-        if (key.startsWith("$")) {
-          throw new ValidationError(`Invalid field name: ${key}`);
-        }
-      }
-      const ctx = createHookContext({
-        collection: collectionName,
-        operation: "patch",
-        req,
-        res,
-        id,
-        data
-      });
-      await executeHook(config.hooks, "beforeUpdate", ctx, logger);
-      if (ctx.preventDefault) return;
-      const doc = await model.findByIdAndUpdate(id, { $set: ctx.data ?? data }, { new: true, runValidators: true }).lean().exec();
-      if (!doc) {
-        throw new NotFoundError(collectionName, id);
-      }
-      ctx.result = doc;
-      await executeHook(config.hooks, "afterUpdate", ctx, logger);
-      const response = { data: ctx.result ?? doc };
-      res.json(response);
-    } catch (error) {
-      next(error);
-    }
+async function deleteDocument(req, res, opts) {
+  const { collectionName, model, config, logger } = opts;
+  const { id } = req.params;
+  const ctx = createCtx(collectionName, "delete", req, res, { id });
+  await runHook(config.hooks, "beforeDelete", ctx, logger);
+  if (ctx.preventDefault) return { statusCode: 0, data: null };
+  const doc = await model.findByIdAndDelete(id).lean().exec();
+  if (!doc) throw new NotFoundError(collectionName, id);
+  ctx.result = doc;
+  await runHook(config.hooks, "afterDelete", ctx, logger);
+  return { statusCode: 200, data: ctx.result ?? doc };
+}
+
+// src/adapters/framework/express.ts
+function toMonapiRequest(req) {
+  return {
+    params: req.params,
+    query: req.query,
+    body: req.body,
+    headers: req.headers,
+    method: req.method,
+    path: req.path,
+    user: req.user,
+    raw: req
   };
 }
-function createDeleteHandler(collectionName, model, config, logger) {
-  return async (req, res, next) => {
-    try {
-      const { id } = req.params;
-      const ctx = createHookContext({
-        collection: collectionName,
-        operation: "delete",
-        req,
-        res,
-        id
-      });
-      await executeHook(config.hooks, "beforeDelete", ctx, logger);
-      if (ctx.preventDefault) return;
-      const doc = await model.findByIdAndDelete(id).lean().exec();
-      if (!doc) {
-        throw new NotFoundError(collectionName, id);
-      }
-      ctx.result = doc;
-      await executeHook(config.hooks, "afterDelete", ctx, logger);
-      res.json({ data: ctx.result ?? doc });
-    } catch (error) {
-      next(error);
+function toMonapiResponse(res) {
+  const wrapper = {
+    raw: res,
+    status(code) {
+      res.status(code);
+      return wrapper;
+    },
+    json(data) {
+      res.json(data);
+    },
+    setHeader(key, value) {
+      res.setHeader(key, value);
+      return wrapper;
     }
   };
+  return wrapper;
 }
-
-// src/middleware/auth.ts
-var ROUTE_TO_CRUD = {
-  list: "find",
-  get: "find",
-  create: "create",
-  update: "update",
-  patch: "patch",
-  delete: "delete"
-};
-function createPermissionMiddleware(collection, routeOp, permissions) {
-  return async (req, _res, next) => {
-    try {
-      if (!permissions) {
-        next();
-        return;
+var ExpressAdapter = class {
+  constructor() {
+    this.name = "express";
+  }
+  createRouter(collections, options) {
+    const mainRouter = express.Router();
+    const basePath = options?.basePath ?? "";
+    for (const [name, ctx] of collections) {
+      const collectionRouter = this.buildCollectionRouter(ctx, options?.authMiddleware);
+      const path = basePath ? `${basePath}/${name}` : `/${name}`;
+      mainRouter.use(path, collectionRouter);
+    }
+    return mainRouter;
+  }
+  wrapHandler(handler) {
+    return async (req, res, next) => {
+      try {
+        await handler(toMonapiRequest(req), toMonapiResponse(res));
+      } catch (error) {
+        next(error);
       }
-      const permission = permissions[routeOp];
-      if (!permission) {
-        next();
+    };
+  }
+  createErrorHandler(logger) {
+    return (err, _req, res, _next) => {
+      if (err instanceof MonapiError) {
+        if (logger) logger.warn(`${err.code}: ${err.message}`, { statusCode: err.statusCode });
+        res.status(err.statusCode).json({
+          error: { code: err.code, message: err.message, details: err.details }
+        });
         return;
       }
-      const user = req.user;
-      if (!user) {
-        throw new UnauthorizedError();
+      if (logger) logger.error(`Unhandled error: ${err.message}`, { stack: err.stack });
+      const message = process.env.NODE_ENV === "production" ? "Internal server error" : err.message;
+      res.status(500).json({ error: { code: "INTERNAL_ERROR", message } });
+    };
+  }
+  buildCollectionRouter(ctx, authMiddleware) {
+    const router = express.Router();
+    const { name, config } = ctx;
+    const ops = ["list", "get", "create", "update", "patch", "delete"];
+    const opHandlers = {
+      list: (mReq, mRes) => this.handleOp(listDocuments, mReq, mRes, ctx),
+      get: (mReq, mRes) => this.handleOp(getDocument, mReq, mRes, ctx),
+      create: (mReq, mRes) => this.handleOp(createDocument, mReq, mRes, ctx),
+      update: (mReq, mRes) => this.handleOp(updateDocument, mReq, mRes, ctx),
+      patch: (mReq, mRes) => this.handleOp(patchDocument, mReq, mRes, ctx),
+      delete: (mReq, mRes) => this.handleOp(deleteDocument, mReq, mRes, ctx)
+    };
+    for (const op of ops) {
+      const stack = [];
+      if (authMiddleware) stack.push(authMiddleware);
+      if (config.middleware?.all) stack.push(...config.middleware.all);
+      if (config.middleware?.[op]) stack.push(...config.middleware[op]);
+      if (config.permissions) {
+        stack.push(async (req, _res, next) => {
+          try {
+            await checkPermissions(toMonapiRequest(req), name, op, config.permissions);
+            next();
+          } catch (error) {
+            next(error);
+          }
+        });
       }
-      const crudOp = ROUTE_TO_CRUD[routeOp] || routeOp;
-      const allowed = await checkPermission(permission, {
-        user,
-        collection,
-        operation: crudOp,
-        data: req.body,
-        id: req.params.id,
-        req
-      });
-      if (!allowed) {
-        throw new ForbiddenError();
+      const handler = config.handlers?.[op] ? config.handlers[op] : this.wrapHandler(opHandlers[op]);
+      switch (op) {
+        case "list":
+          router.get("/", ...stack, handler);
+          break;
+        case "get":
+          router.get("/:id", ...stack, handler);
+          break;
+        case "create":
+          router.post("/", ...stack, handler);
+          break;
+        case "update":
+          router.put("/:id", ...stack, handler);
+          break;
+        case "patch":
+          router.patch("/:id", ...stack, handler);
+          break;
+        case "delete":
+          router.delete("/:id", ...stack, handler);
+          break;
       }
-      next();
-    } catch (error) {
-      next(error);
     }
+    return router;
+  }
+  async handleOp(operation, mReq, mRes, ctx) {
+    const result = await operation(mReq, mRes, {
+      collectionName: ctx.name,
+      model: ctx.model,
+      adapter: ctx.adapter,
+      config: ctx.config,
+      defaults: ctx.defaults,
+      logger: ctx.logger
+    });
+    if (result.statusCode === 0) return;
+    if (result.meta) {
+      mRes.status(result.statusCode).json({ data: result.data, meta: result.meta });
+    } else {
+      mRes.status(result.statusCode).json({ data: result.data });
+    }
+  }
+};
+
+// src/adapters/framework/hono.ts
+function toMonapiRequest2(c) {
+  return {
+    params: c.req.param() || {},
+    query: c.req.query() || {},
+    body: null,
+    // body is async in Hono - set separately
+    headers: Object.fromEntries(c.req.raw.headers.entries()),
+    method: c.req.method,
+    path: c.req.path,
+    user: c.get("user"),
+    raw: c
   };
 }
-async function checkPermission(permission, ctx) {
-  if (Array.isArray(permission)) {
-    if (!ctx.user.roles || ctx.user.roles.length === 0) {
-      return false;
+function toMonapiResponse2(c) {
+  let statusCode = 200;
+  let responseData = null;
+  const wrapper = {
+    raw: c,
+    status(code) {
+      statusCode = code;
+      return wrapper;
+    },
+    json(data) {
+      responseData = data;
+    },
+    setHeader(key, value) {
+      c.header(key, value);
+      return wrapper;
     }
-    return permission.some((role) => ctx.user.roles?.includes(role));
+  };
+  wrapper._getResponse = () => ({ statusCode, data: responseData });
+  return wrapper;
+}
+var HonoAdapter = class {
+  constructor() {
+    this.name = "hono";
   }
-  if (typeof permission === "function") {
-    return permission(ctx);
+  /**
+   * Returns a Hono app instance with all collection routes registered.
+   * Expects Hono to be available at runtime (peer dependency).
+   */
+  createRouter(collections, options) {
+    let Hono;
+    try {
+      Hono = __require("hono").Hono;
+    } catch {
+      throw new Error(
+        "Hono is required for the Hono adapter. Install it: npm install hono"
+      );
+    }
+    const app = new Hono();
+    if (options?.authMiddleware) {
+      app.use("*", options.authMiddleware);
+    }
+    app.onError((err, c) => {
+      if (err instanceof MonapiError) {
+        return c.json(
+          { error: { code: err.code, message: err.message, details: err.details } },
+          err.statusCode
+        );
+      }
+      const message = process.env.NODE_ENV === "production" ? "Internal server error" : err.message;
+      return c.json({ error: { code: "INTERNAL_ERROR", message } }, 500);
+    });
+    for (const [name, ctx] of collections) {
+      this.registerCollectionRoutes(app, `/${name}`, ctx);
+    }
+    return app;
   }
-  return false;
-}
-function createAuthMiddleware(authConfig) {
-  if (authConfig?.middleware) {
-    return authConfig.middleware;
+  wrapHandler(handler) {
+    return async (c) => {
+      const mReq = toMonapiRequest2(c);
+      if (["POST", "PUT", "PATCH"].includes(c.req.method)) {
+        try {
+          mReq.body = await c.req.json();
+        } catch {
+          mReq.body = {};
+        }
+      }
+      const mRes = toMonapiResponse2(c);
+      await handler(mReq, mRes);
+      const { statusCode, data } = mRes._getResponse();
+      if (data !== null) {
+        return c.json(data, statusCode);
+      }
+    };
   }
-  return (_req, _res, next) => {
-    next();
-  };
-}
-
-// src/router/express-router.ts
-function createCollectionRouter(options) {
-  const { collectionName, model, adapter, config, defaults, logger, authMiddleware } = options;
-  const router = express.Router();
-  const handlers = createCRUDHandlers({ collectionName, model, adapter, config, defaults, logger });
-  const operations = ["list", "get", "create", "update", "patch", "delete"];
-  const middlewareStacks = {};
-  for (const op of operations) {
-    const stack = [];
-    if (authMiddleware) {
-      stack.push(authMiddleware);
-    }
-    if (config.middleware?.all) {
-      stack.push(...config.middleware.all);
-    }
-    const opMiddleware = config.middleware?.[op];
-    if (opMiddleware) {
-      stack.push(...opMiddleware);
-    }
-    if (config.permissions) {
-      stack.push(createPermissionMiddleware(collectionName, op, config.permissions));
-    }
-    middlewareStacks[op] = stack;
-  }
-  router.get("/", ...middlewareStacks.list, handlers.list);
-  router.get("/:id", ...middlewareStacks.get, handlers.get);
-  router.post("/", ...middlewareStacks.create, handlers.create);
-  router.put("/:id", ...middlewareStacks.update, handlers.update);
-  router.patch("/:id", ...middlewareStacks.patch, handlers.patch);
-  router.delete("/:id", ...middlewareStacks.delete, handlers.delete);
-  return router;
-}
-
-// src/middleware/error-handler.ts
-function createErrorHandler(logger) {
-  return (err, _req, res, _next) => {
-    if (err instanceof MonapiError) {
-      if (logger) {
-        logger.warn(`${err.code}: ${err.message}`, { statusCode: err.statusCode });
+  createErrorHandler(logger) {
+    return (err, c) => {
+      if (err instanceof MonapiError) {
+        if (logger) logger.warn(`${err.code}: ${err.message}`);
+        return c.json(
+          { error: { code: err.code, message: err.message, details: err.details } },
+          err.statusCode
+        );
       }
-      const response2 = {
-        error: {
-          code: err.code,
-          message: err.message,
-          details: err.details
+      if (logger) logger.error(`Unhandled error: ${err.message}`);
+      const message = process.env.NODE_ENV === "production" ? "Internal server error" : err.message;
+      return c.json({ error: { code: "INTERNAL_ERROR", message } }, 500);
+    };
+  }
+  registerCollectionRoutes(app, prefix, ctx) {
+    const { name, config } = ctx;
+    const createHandler = (op, handler) => {
+      return async (c) => {
+        const mReq = toMonapiRequest2(c);
+        if (["POST", "PUT", "PATCH"].includes(c.req.method)) {
+          try {
+            mReq.body = await c.req.json();
+          } catch {
+            mReq.body = {};
+          }
+        }
+        if (config.permissions) {
+          await checkPermissions(mReq, name, op, config.permissions);
+        }
+        const mRes = toMonapiResponse2(c);
+        const result = await handler(mReq, mRes, {
+          collectionName: ctx.name,
+          model: ctx.model,
+          adapter: ctx.adapter,
+          config: ctx.config,
+          defaults: ctx.defaults,
+          logger: ctx.logger
+        });
+        if (result.statusCode === 0) return c.body(null, 204);
+        if (result.meta) {
+          return c.json({ data: result.data, meta: result.meta }, result.statusCode);
         }
+        return c.json({ data: result.data }, result.statusCode);
       };
-      res.status(err.statusCode).json(response2);
-      return;
-    }
-    if (logger) {
-      logger.error(`Unhandled error: ${err.message}`, { stack: err.stack });
-    }
-    const message = process.env.NODE_ENV === "production" ? "Internal server error" : err.message;
-    const response = {
-      error: {
-        code: "INTERNAL_ERROR",
-        message
-      }
     };
-    res.status(500).json(response);
-  };
+    app.get(prefix, createHandler("list", listDocuments));
+    app.get(`${prefix}/:id`, createHandler("get", getDocument));
+    app.post(prefix, createHandler("create", createDocument));
+    app.put(`${prefix}/:id`, createHandler("update", updateDocument));
+    app.patch(`${prefix}/:id`, createHandler("patch", patchDocument));
+    app.delete(`${prefix}/:id`, createHandler("delete", deleteDocument));
+  }
+};
+
+// src/adapters/framework/index.ts
+function resolveFrameworkAdapter(framework) {
+  if (!framework || framework === "express") {
+    return new ExpressAdapter();
+  }
+  if (typeof framework === "string") {
+    switch (framework) {
+      case "hono":
+        return new HonoAdapter();
+      default:
+        throw new Error(`Unknown framework: ${framework}. Use 'express', 'hono', or pass a custom FrameworkAdapter.`);
+    }
+  }
+  return framework;
 }
 
 // src/utils/logger.ts
@@ -921,9 +1035,10 @@ var Monapi = class {
     this.collections = /* @__PURE__ */ new Map();
     this.config = config;
     this.logger = config.logger ?? defaultLogger;
-    if (config.auth) {
-      this.authMiddleware = createAuthMiddleware(config.auth);
-    }
+    this.frameworkAdapter = resolveFrameworkAdapter(
+      config.framework
+    );
+    this.logger.debug(`Using framework adapter: ${this.frameworkAdapter.name}`);
   }
   /**
    * Register a collection resource.
@@ -932,43 +1047,56 @@ var Monapi = class {
   resource(name, collectionConfig) {
     const adapter = collectionConfig.adapter ?? createSchemaAdapter(collectionConfig.schema);
     const model = this.resolveModel(name, collectionConfig, adapter);
-    this.collections.set(name, { config: collectionConfig, model, adapter });
+    this.collections.set(name, {
+      name,
+      model,
+      adapter,
+      config: collectionConfig,
+      defaults: this.config.defaults,
+      logger: this.logger
+    });
     this.logger.debug(`Registered resource: ${name}`, {
       fields: adapter.getFields()
     });
     return this;
   }
   /**
-   * Generate the Express router with all registered collection routes.
+   * Generate the framework-specific router with all registered collection routes.
+   *
+   * - Express: returns an Express Router
+   * - Fastify: returns a Fastify plugin function
+   * - Hono: returns a Hono app instance
+   * - NestJS: returns a dynamic module definition
    */
   router() {
-    const mainRouter = express.Router();
-    const basePath = this.config.basePath ?? "";
-    for (const [name, { config, model, adapter }] of this.collections) {
-      const collectionRouter = createCollectionRouter({
-        collectionName: name,
-        model,
-        adapter,
-        config,
-        defaults: this.config.defaults,
-        logger: this.logger,
-        authMiddleware: this.authMiddleware
-      });
+    const result = this.frameworkAdapter.createRouter(this.collections, {
+      basePath: this.config.basePath,
+      authMiddleware: this.config.auth?.middleware
+    });
+    if (this.frameworkAdapter.name === "express") {
+      result.use(this.frameworkAdapter.createErrorHandler(this.logger));
+    }
+    for (const [name] of this.collections) {
+      const basePath = this.config.basePath ?? "";
       const path = basePath ? `${basePath}/${name}` : `/${name}`;
-      mainRouter.use(path, collectionRouter);
-      this.logger.info(`Mounted routes: ${path}`);
+      this.logger.info(`Mounted routes: ${path} [${this.frameworkAdapter.name}]`);
     }
-    mainRouter.use(createErrorHandler(this.logger));
-    return mainRouter;
+    return result;
+  }
+  /**
+   * Get the framework adapter instance.
+   */
+  getFrameworkAdapter() {
+    return this.frameworkAdapter;
   }
   /**
-   * Get a registered collection's model
+   * Get a registered collection's model.
    */
   getModel(name) {
     return this.collections.get(name)?.model;
   }
   /**
-   * Get a registered collection's adapter
+   * Get a registered collection's adapter.
    */
   getAdapter(name) {
     return this.collections.get(name)?.adapter;
@@ -995,9 +1123,42 @@ var Monapi = class {
   }
 };
 
+// src/middleware/error-handler.ts
+function createErrorHandler(logger) {
+  return (err, _req, res, _next) => {
+    if (err instanceof MonapiError) {
+      if (logger) {
+        logger.warn(`${err.code}: ${err.message}`, { statusCode: err.statusCode });
+      }
+      const response2 = {
+        error: {
+          code: err.code,
+          message: err.message,
+          details: err.details
+        }
+      };
+      res.status(err.statusCode).json(response2);
+      return;
+    }
+    if (logger) {
+      logger.error(`Unhandled error: ${err.message}`, { stack: err.stack });
+    }
+    const message = process.env.NODE_ENV === "production" ? "Internal server error" : err.message;
+    const response = {
+      error: {
+        code: "INTERNAL_ERROR",
+        message
+      }
+    };
+    res.status(500).json(response);
+  };
+}
+
 exports.BadRequestError = BadRequestError;
+exports.ExpressAdapter = ExpressAdapter;
 exports.FieldType = FieldType;
 exports.ForbiddenError = ForbiddenError;
+exports.HonoAdapter = HonoAdapter;
 exports.Monapi = Monapi;
 exports.MonapiError = MonapiError;
 exports.MongooseAdapter = MongooseAdapter;
@@ -1007,9 +1168,17 @@ exports.UnauthorizedError = UnauthorizedError;
 exports.ValidationError = ValidationError;
 exports.buildPaginationMeta = buildPaginationMeta;
 exports.buildQuery = buildQuery;
+exports.checkPermissions = checkPermissions;
+exports.createDocument = createDocument;
 exports.createErrorHandler = createErrorHandler;
 exports.createSchemaAdapter = createSchemaAdapter;
+exports.deleteDocument = deleteDocument;
 exports.detectSchemaType = detectSchemaType;
+exports.getDocument = getDocument;
+exports.listDocuments = listDocuments;
 exports.parseFilters = parseFilters;
+exports.patchDocument = patchDocument;
+exports.resolveFrameworkAdapter = resolveFrameworkAdapter;
+exports.updateDocument = updateDocument;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map