balda-js 0.0.2 → 0.0.4

package/lib/index.js

@@ -1,3327 +0,0 @@
-// src/decorators/controller/controller.ts
-import { join } from "path";
-
-// src/metadata_store.ts
-var MetadataStore = class {
-  static metadata = /* @__PURE__ */ new WeakMap();
-  /**
-   * Set the metadata for the given target and property key
-   */
-  static set(target, propertyKey, value) {
-    if (!this.metadata.has(target)) {
-      this.metadata.set(target, /* @__PURE__ */ new Map());
-    }
-    this.metadata.get(target).set(propertyKey, value);
-  }
-  /**
-   * Get the metadata for the given target and property key
-   */
-  static get(target, propertyKey) {
-    return this.metadata.get(target)?.get(propertyKey);
-  }
-  /**
-   * Get all the metadata for the given target
-   */
-  static getAll(target) {
-    return this.metadata.get(target) || /* @__PURE__ */ new Map();
-  }
-  /**
-   * Delete the metadata for the given target and property key
-   */
-  static delete(target, propertyKey) {
-    this.metadata.get(target)?.delete(propertyKey.toString());
-  }
-  /**
-   * Clear all the metadata for the given target
-   */
-  static clear(target) {
-    this.metadata.delete(target);
-  }
-};
-
-// src/server/router/router.ts
-var Node = class {
-  staticChildren;
-  paramChild;
-  wildcardChild;
-  middleware;
-  handler;
-  constructor() {
-    this.staticChildren = /* @__PURE__ */ new Map();
-    this.paramChild = null;
-    this.wildcardChild = null;
-    this.middleware = null;
-    this.handler = null;
-  }
-};
-var Router = class {
-  trees;
-  routes;
-  constructor() {
-    this.trees = /* @__PURE__ */ new Map();
-    this.routes = [];
-  }
-  getRoutes() {
-    return this.routes.slice();
-  }
-  addOrUpdate(method, path, middleware2, handler, swaggerOptions) {
-    method = method.toUpperCase();
-    let root = this.trees.get(method);
-    if (!root) {
-      root = new Node();
-      this.trees.set(method, root);
-    }
-    const clean = path.split("?")[0];
-    const segments = clean.replace(/^\/+|\/+$/g, "").split("/");
-    let node = root;
-    for (const seg of segments) {
-      if (seg === "*") {
-        if (!node.wildcardChild) {
-          node.wildcardChild = new Node();
-        }
-        node = node.wildcardChild;
-        break;
-      }
-      if (seg.startsWith(":")) {
-        const name = seg.slice(1);
-        if (!node.paramChild) {
-          node.paramChild = { node: new Node(), name };
-        }
-        node = node.paramChild.node;
-        continue;
-      }
-      if (!node.staticChildren.has(seg)) {
-        node.staticChildren.set(seg, new Node());
-      }
-      node = node.staticChildren.get(seg);
-    }
-    node.middleware = middleware2;
-    node.handler = handler;
-    const idx = this.routes.findIndex(
-      (r) => r.method === method && r.path === path
-    );
-    if (idx !== -1) {
-      this.routes[idx].middleware = middleware2;
-      this.routes[idx].handler = handler;
-      return;
-    }
-    this.routes.push({ method, path, middleware: middleware2, handler, swaggerOptions });
-  }
-  find(method, rawPath) {
-    method = method.toUpperCase();
-    const root = this.trees.get(method);
-    if (!root) {
-      return null;
-    }
-    const clean = rawPath.split("?")[0];
-    const segments = clean.replace(/^\/+|\/+$/g, "").split("/");
-    const params = {};
-    let node = root;
-    for (let i = 0; i < segments.length; i++) {
-      const seg = segments[i];
-      if (node.staticChildren.has(seg)) {
-        node = node.staticChildren.get(seg);
-        continue;
-      }
-      if (node.paramChild) {
-        params[node.paramChild.name] = seg;
-        node = node.paramChild.node;
-        continue;
-      }
-      if (node.wildcardChild) {
-        params["*"] = segments.slice(i).join("/");
-        node = node.wildcardChild;
-        break;
-      }
-      return null;
-    }
-    if (!node.handler || !node.middleware) {
-      return null;
-    }
-    return { middleware: node.middleware, handler: node.handler, params };
-  }
-  /**
-   * Apply global middlewares to all routes
-   * @param middlewares - The middlewares to apply
-   * @internal
-   */
-  applyGlobalMiddlewaresToAllRoutes(middlewares) {
-    for (const route of this.routes) {
-      this.addOrUpdate(
-        route.method,
-        route.path,
-        [...middlewares, ...route.middleware || []],
-        route.handler
-      );
-    }
-  }
-};
-var router = new Router();
-
-// src/decorators/controller/controller.ts
-var controller = (path, swaggerOptions) => {
-  return (target) => {
-    const classMeta = MetadataStore.get(target.prototype, "__class__");
-    const classMiddlewares = classMeta?.middlewares || [];
-    const metaMap = MetadataStore.getAll(target.prototype);
-    for (const [propertyKey, meta] of metaMap.entries()) {
-      if (!meta.route) {
-        continue;
-      }
-      const handler = target.prototype[propertyKey];
-      const fullPath = path ? join(path, meta.route.path) : meta.route.path;
-      const allMiddlewares = [...classMiddlewares, ...meta.middlewares || []];
-      router.addOrUpdate(
-        meta.route.method,
-        fullPath,
-        allMiddlewares,
-        handler,
-        {
-          // default service name
-          service: target.name.replace(/Controller$/, ""),
-          // controller options
-          ...swaggerOptions,
-          // route options
-          ...meta.documentation
-        }
-      );
-    }
-    MetadataStore.clear(target.prototype);
-  };
-};
-
-// src/decorators/handlers/del.ts
-var del = (path, options) => {
-  return (target, propertyKey, descriptor) => {
-    let meta = MetadataStore.get(target, propertyKey);
-    if (!meta) {
-      meta = { middlewares: [], route: { path, method: "DELETE" } };
-    }
-    meta.documentation = {
-      ...meta.documentation || {},
-      name: propertyKey,
-      ...options
-    };
-    meta.route = { path, method: "DELETE" };
-    MetadataStore.set(target, propertyKey, meta);
-    return descriptor;
-  };
-};
-
-// src/decorators/handlers/get.ts
-var get = (path, options) => {
-  return (target, propertyKey, descriptor) => {
-    let meta = MetadataStore.get(target, propertyKey);
-    if (!meta) {
-      meta = { middlewares: [], route: { path, method: "GET" } };
-    }
-    meta.documentation = {
-      ...meta.documentation || {},
-      name: propertyKey,
-      ...options
-    };
-    meta.route = { path, method: "GET" };
-    MetadataStore.set(target, propertyKey, meta);
-    return descriptor;
-  };
-};
-
-// src/decorators/handlers/patch.ts
-var patch = (path, options) => {
-  return (target, propertyKey, descriptor) => {
-    let meta = MetadataStore.get(target, propertyKey);
-    if (!meta) {
-      meta = { middlewares: [], route: { path, method: "PATCH" } };
-    }
-    meta.documentation = {
-      ...meta.documentation || {},
-      name: propertyKey,
-      ...options
-    };
-    meta.route = { path, method: "PATCH" };
-    MetadataStore.set(target, propertyKey, meta);
-    return descriptor;
-  };
-};
-
-// src/decorators/handlers/post.ts
-var post = (path, options) => {
-  return (target, propertyKey, descriptor) => {
-    let meta = MetadataStore.get(target, propertyKey);
-    if (!meta) {
-      meta = { middlewares: [], route: { path, method: "POST" } };
-    }
-    meta.documentation = {
-      ...meta.documentation || {},
-      name: propertyKey,
-      ...options
-    };
-    meta.route = { path, method: "POST" };
-    MetadataStore.set(target, propertyKey, meta);
-    return descriptor;
-  };
-};
-
-// src/decorators/handlers/put.ts
-var put = (path, options) => {
-  return (target, propertyKey, descriptor) => {
-    let meta = MetadataStore.get(target, propertyKey);
-    if (!meta) {
-      meta = { middlewares: [], route: { path, method: "PUT" } };
-    }
-    meta.documentation = {
-      ...meta.documentation || {},
-      name: propertyKey,
-      ...options
-    };
-    meta.route = { path, method: "PUT" };
-    MetadataStore.set(target, propertyKey, meta);
-    return descriptor;
-  };
-};
-
-// src/decorators/middleware/middleware.ts
-var middleware = (middleware2) => {
-  return (target, propertyKey, descriptor) => {
-    if (typeof propertyKey === "undefined") {
-      let meta2 = MetadataStore.get(target.prototype, "__class__");
-      if (!meta2) {
-        meta2 = { middlewares: [] };
-      }
-      if (!meta2.middlewares) {
-        meta2.middlewares = [];
-      }
-      if (!middleware2) {
-        throw new Error(
-          `Middleware ${String(
-            middleware2
-          )} not found, are you sure you defined it before using it?`
-        );
-      }
-      if (!Array.isArray(middleware2)) {
-        middleware2 = [middleware2];
-      }
-      meta2.middlewares.push(...middleware2);
-      MetadataStore.set(target.prototype, "__class__", meta2);
-      return target;
-    }
-    let meta = MetadataStore.get(target, propertyKey);
-    if (!meta) {
-      meta = { middlewares: [] };
-    }
-    if (!meta.middlewares) {
-      meta.middlewares = [];
-    }
-    if (!Array.isArray(middleware2)) {
-      middleware2 = [middleware2];
-    }
-    meta.middlewares.push(...middleware2);
-    MetadataStore.set(target, propertyKey, meta);
-    return descriptor;
-  };
-};
-
-// src/decorators/validation/validate.ts
-import { ValidationError } from "ajv";
-var validateDecorator = (options) => {
-  return (target, propertyKey, descriptor) => {
-    const originalMethod = descriptor.value;
-    let meta = MetadataStore.get(target, propertyKey);
-    if (!meta) {
-      meta = { middlewares: [], route: {} };
-    }
-    if (!meta.documentation) {
-      meta.documentation = {};
-    }
-    if (options.body) {
-      meta.documentation.requestBody = options.body;
-    }
-    if (options.query) {
-      meta.documentation.query = options.query;
-    }
-    MetadataStore.set(target, propertyKey, meta);
-    descriptor.value = async function(...args) {
-      const req = args[0];
-      const res = args[1];
-      try {
-        let validatedBody = void 0;
-        let validatedQuery = void 0;
-        let validatedAll = void 0;
-        if (options.body) {
-          validatedBody = req.validate(options.body, options.safe);
-        }
-        if (options.query) {
-          validatedQuery = req.validateQuery(options.query, options.safe);
-        }
-        if (options.all) {
-          validatedAll = req.validateAll(options.all, options.safe);
-        }
-        const newArgs = [...args];
-        if (validatedBody !== void 0) {
-          newArgs.push(validatedBody);
-        }
-        if (validatedQuery !== void 0) {
-          newArgs.push(validatedQuery);
-        }
-        if (validatedAll !== void 0) {
-          newArgs.push(validatedAll);
-        }
-        return originalMethod.apply(this, newArgs);
-      } catch (error) {
-        if (!(error instanceof ValidationError)) {
-          throw error;
-        }
-        if (options.customError) {
-          return res.status(options.customError.status || 400).json({
-            received: req.body,
-            schema: options.body,
-            error: error.errors
-          });
-        }
-        return res.badRequest(error);
-      }
-    };
-    return descriptor;
-  };
-};
-validateDecorator.query = (schema, customError) => {
-  return validateDecorator({ query: schema, customError });
-};
-validateDecorator.body = (schema, customError) => {
-  return validateDecorator({ body: schema, customError });
-};
-validateDecorator.all = (schema, customError) => {
-  return validateDecorator({ all: schema, customError });
-};
-var validate = validateDecorator;
-
-// src/server/http/request.ts
-import { Type } from "@sinclair/typebox";
-
-// src/validator/validator.ts
-import Ajv, { ValidationError as ValidationError2 } from "ajv";
-import addFormats from "ajv-formats";
-var ajv = addFormats(new Ajv(), [
-  "date-time",
-  "time",
-  "date",
-  "email",
-  "hostname",
-  "ipv4",
-  "ipv6",
-  "uri",
-  "uri-reference",
-  "uuid",
-  "uri-template",
-  "json-pointer",
-  "relative-json-pointer",
-  "regex",
-  "password",
-  "binary",
-  "byte",
-  "iso-date-time",
-  "iso-time"
-]);
-var validateSchema = (inputSchema, data, safe = false) => {
-  const validate2 = ajv.compile(inputSchema);
-  if (!validate2(data)) {
-    if (safe) {
-      return data;
-    }
-    throw new ValidationError2(validate2.errors || []);
-  }
-  return data;
-};
-
-// src/runtime/native_request.ts
-var NativeRequest = class extends Request {
-};
-
-// src/server/http/request.ts
-import { randomUUID } from "crypto";
-var Request2 = class _Request extends NativeRequest {
-  static fromRequest(request) {
-    return new _Request(request.url, {
-      method: request.method,
-      body: request.body,
-      headers: request.headers
-    });
-  }
-  /**
-   * Enrich native request with validation methods.
-   */
-  static enrichRequest(request) {
-    request.validate = (inputSchema, safe = false) => {
-      if (typeof inputSchema === "function") {
-        inputSchema = inputSchema(Type);
-      }
-      return validateSchema(inputSchema, request.body || {}, safe);
-    };
-    request.validateQuery = (inputSchema, safe = false) => {
-      if (typeof inputSchema === "function") {
-        inputSchema = inputSchema(Type);
-      }
-      return validateSchema(inputSchema, request.query || {}, safe);
-    };
-    request.validateAll = (inputSchema, safe = false) => {
-      if (typeof inputSchema === "function") {
-        inputSchema = inputSchema(Type);
-      }
-      return validateSchema(
-        inputSchema,
-        {
-          ...request.body ? { body: request.body } : {},
-          ...request.query ? { query: request.query } : {}
-        },
-        safe
-      );
-    };
-    request.file = (fieldName) => {
-      return request.files.find((file) => file.formName === fieldName) ?? null;
-    };
-    request.cookies = {};
-    request.cookie = (name) => {
-      return request.cookies[name];
-    };
-    request.files = [];
-    return request;
-  }
-  /**
-   * The file of the request. Only available for multipart/form-data requests and if the file parser middleware is used.
-   */
-  file = (fieldName) => {
-    return this.files.find((file) => file.formName === fieldName) ?? null;
-  };
-  /**
-   * The cookies of the request. Only available if the cookie middleware is used.
-   */
-  cookies = {};
-  /**
-   * The cookie of the request. Only available if the cookie middleware is used.
-   */
-  cookie = (name) => {
-    return this.cookies[name];
-  };
-  /**
-   * The ip address of the request.
-   * Tries to get the ip address from the `x-forwarded-for` header. If not available, it will use the remote address from the request.
-   */
-  ip;
-  /**
-   * The files of the request. Only available for multipart/form-data requests and if the file parser middleware is used.
-   */
-  files = [];
-  /**
-   * The parameters of the request.
-   */
-  params = {};
-  /**
-   * The query parameters of the request.
-   */
-  query = {};
-  /**
-   * The id of the request.
-   */
-  get id() {
-    if (!this._id) {
-      this._id = randomUUID();
-    }
-    return this._id;
-  }
-  /**
-   * The parsed body of the request
-   */
-  body;
-  /**
-   * The validated body of the request.
-   * @param inputSchema - The schema to validate the body against.
-   * @param safe - If true, the function will return the original body if the validation fails instead of throwing an error.
-   */
-  validate(inputSchema, safe = false) {
-    if (typeof inputSchema === "function") {
-      inputSchema = inputSchema(Type);
-    }
-    return validateSchema(inputSchema, this.body || {}, safe);
-  }
-  /**
-   * Validates the query string of the request.
-   */
-  validateQuery(inputSchema, safe = false) {
-    if (typeof inputSchema === "function") {
-      inputSchema = inputSchema(Type);
-    }
-    return validateSchema(inputSchema, this.query || {}, safe);
-  }
-  /**
-   * Validates the body and query string of the request.
-   */
-  validateAll(inputSchema, safe = false) {
-    if (typeof inputSchema === "function") {
-      inputSchema = inputSchema(Type);
-    }
-    return validateSchema(
-      inputSchema,
-      {
-        ...this.body ? { body: this.body } : {},
-        ...this.query ? { query: this.query } : {}
-      },
-      safe
-    );
-  }
-};
-
-// src/runtime/runtime.ts
-var RunTime = class {
-  type;
-  constructor() {
-    this.type = this.getRunTime();
-  }
-  getRunTime() {
-    if (typeof Bun !== "undefined") {
-      return "bun";
-    } else if (typeof Deno !== "undefined") {
-      return "deno";
-    } else if (typeof process !== "undefined") {
-      return "node";
-    }
-    throw new Error("No environment detected");
-  }
-};
-var runtime = new RunTime();
-
-// src/runtime/native_file.ts
-import fs from "fs/promises";
-var NativeFile = class {
-  file(path) {
-    switch (runtime.type) {
-      case "bun":
-        return Bun.file(path);
-      case "node":
-        return fs.readFile(path);
-      case "deno":
-        return Deno.readFile(path);
-      default:
-        throw new Error("Unsupported runtime");
-    }
-  }
-};
-var nativeFile = new NativeFile();
-
-// src/plugins/static/static.ts
-import { extname, join as join2, resolve } from "path";
-
-// src/plugins/static/static_constants.ts
-var mimeTypes = /* @__PURE__ */ new Map([
-  [".html", "text/html"],
-  [".css", "text/css"],
-  [".js", "application/javascript"],
-  [".png", "image/png"],
-  [".jpg", "image/jpeg"],
-  [".gif", "image/gif"],
-  [".svg", "image/svg+xml"],
-  [".json", "application/json"],
-  [".txt", "text/plain"],
-  [".ico", "image/x-icon"],
-  [".webp", "image/webp"],
-  [".mp4", "video/mp4"],
-  [".mp3", "audio/mpeg"],
-  [".wav", "audio/wav"],
-  [".ogg", "audio/ogg"],
-  [".webm", "video/webm"]
-]);
-
-// src/runtime/native_cwd.ts
-var NativeCwd = class {
-  getCwd() {
-    switch (runtime.type) {
-      case "node":
-      case "bun":
-        return process.cwd();
-      case "deno":
-        return Deno.cwd();
-      default:
-        throw new Error("Unsupported runtime");
-    }
-  }
-};
-var nativeCwd = new NativeCwd();
-
-// src/runtime/native_fs.ts
-var NativeFs = class {
-  async readFile(path) {
-    switch (runtime.type) {
-      case "node":
-        const fs2 = await import("fs/promises");
-        const buffer = await fs2.readFile(path);
-        return new Uint8Array(buffer);
-      case "bun":
-        const arrayBuffer = await Bun.file(path).arrayBuffer();
-        return new Uint8Array(arrayBuffer);
-      case "deno":
-        return new Uint8Array(await Deno.readFile(path));
-    }
-  }
-  async writeFile(path, data) {
-    switch (runtime.type) {
-      case "node":
-        const fs2 = await import("fs/promises");
-        await fs2.writeFile(path, data);
-        break;
-      case "bun":
-        await Bun.write(path, data);
-        break;
-      case "deno":
-        await Deno.writeFile(path, data);
-        break;
-    }
-  }
-  async stat(path) {
-    switch (runtime.type) {
-      case "node":
-        const fs2 = await import("fs/promises");
-        const stats = await fs2.stat(path);
-        return {
-          isDirectory: stats.isDirectory(),
-          isFile: stats.isFile(),
-          isSymbolicLink: stats.isSymbolicLink(),
-          size: stats.size
-        };
-      case "bun":
-        const bunStats = await Bun.file(path).stat();
-        return {
-          isDirectory: bunStats.isDirectory(),
-          isFile: bunStats.isFile(),
-          isSymbolicLink: bunStats.isSymbolicLink(),
-          size: bunStats.size
-        };
-      case "deno":
-        const denoStats = await Deno.stat(path);
-        return {
-          isDirectory: denoStats.isDirectory,
-          isFile: denoStats.isFile,
-          isSymbolicLink: false,
-          size: denoStats.size
-        };
-    }
-  }
-  async unlink(path) {
-    switch (runtime.type) {
-      case "node":
-        const fs2 = await import("fs/promises");
-        await fs2.unlink(path);
-        break;
-      case "bun":
-        await Bun.file(path).delete();
-        break;
-      case "deno":
-        await Deno.remove(path);
-        break;
-      default:
-        throw new Error("Unsupported runtime");
-    }
-  }
-};
-var nativeFs = new NativeFs();
-
-// src/errors/balda_error.ts
-var BaldaError = class extends Error {
-  constructor(message) {
-    super(message);
-  }
-};
-
-// src/errors/route_not_found.ts
-var RouteNotFoundError = class extends BaldaError {
-  constructor(path, method) {
-    super(`ROUTE_NOT_FOUND: Cannot ${method} ${path}`);
-  }
-};
-
-// src/errors/error_factory.ts
-var errorFactory = (error) => {
-  return {
-    name: error.constructor.name,
-    cause: error.cause,
-    message: error.message,
-    stack: error.stack
-  };
-};
-
-// src/errors/method_not_allowed.ts
-var MethodNotAllowedError = class extends BaldaError {
-  constructor(path, method) {
-    super(`METHOD_NOT_ALLOWED: Cannot ${method} ${path}`);
-  }
-};
-
-// src/plugins/static/static.ts
-var serveStatic = (path = "public", swaggerOptions) => {
-  router.addOrUpdate(
-    "GET",
-    `${path}/*`,
-    [],
-    async (req, res) => {
-      return staticFileHandler(req, res, path);
-    },
-    {
-      service: "StaticFiles",
-      ...swaggerOptions
-    }
-  );
-  return async (_req, _res, next) => {
-    return next();
-  };
-};
-async function staticFileHandler(req, res, path) {
-  if (req.method !== "GET" && req.method !== "HEAD") {
-    return res.status(405).json({
-      ...errorFactory(new MethodNotAllowedError(req.url, req.method))
-    });
-  }
-  const wildcardPath = req.params["*"] || "";
-  const filePath = join2(path, wildcardPath);
-  const resolvedPath = resolve(nativeCwd.getCwd(), filePath);
-  const stats = await nativeFs.stat(resolvedPath);
-  if (!stats.isFile) {
-    return res.notFound({
-      ...errorFactory(new RouteNotFoundError(req.url, req.method))
-    });
-  }
-  const contentType = getContentType(extname(resolvedPath));
-  res.setHeader("Content-Type", contentType);
-  const fileContent = await nativeFile.file(resolvedPath);
-  res.raw(fileContent);
-}
-function getContentType(ext) {
-  return mimeTypes.get(ext) || "application/octet-stream";
-}
-
-// src/server/http/response.ts
-var Response2 = class {
-  /**
-   * The status of the response
-   */
-  responseStatus;
-  /**
-   * The headers of the response
-   */
-  headers;
-  /**
-   * The body of the response
-   */
-  body;
-  constructor(status = 200) {
-    this.responseStatus = status;
-    this.headers = {};
-  }
-  /**
-   * Set a header for the response
-   */
-  setHeader(key, value) {
-    this.headers[key] = value;
-    return this;
-  }
-  /**
-   * Set the status of the response, status defaults to 200
-   */
-  status(status) {
-    this.responseStatus = status;
-    return this;
-  }
-  /**
-   * Send a response with the given body, tries to determine the content type based on the body type, status defaults to 200
-   * @warning If cannot determine the content type, it will be sent as is
-   */
-  send(body) {
-    if (body === null || body === void 0) {
-      return this.text("");
-    }
-    if (typeof body === "string") {
-      return this.text(body);
-    }
-    if (typeof body === "number" || typeof body === "boolean" || typeof body === "bigint") {
-      return this.text(String(body));
-    }
-    if (body instanceof Date) {
-      return this.text(body.toISOString());
-    }
-    if (body instanceof RegExp) {
-      return this.text(body.toString());
-    }
-    if (typeof Buffer !== "undefined" && body instanceof Buffer) {
-      return this.download(new Uint8Array(body));
-    }
-    if (body instanceof ArrayBuffer || body instanceof Uint8Array) {
-      return this.download(new Uint8Array(body));
-    }
-    if (typeof body === "object" && body !== null) {
-      try {
-        return this.json(body);
-      } catch (error) {
-        return this.text(String(body));
-      }
-    }
-    if (typeof body === "function") {
-      return this.text(body.toString());
-    }
-    if (typeof body === "symbol") {
-      return this.text(body.toString());
-    }
-    this.body = body;
-  }
-  /**
-   * Send a response with the given body without any content type or encoding (as is), status defaults to 200
-   */
-  raw(body) {
-    this.body = body;
-  }
-  /**
-   * Send a response with the given text, status defaults to 200
-   */
-  text(body) {
-    this.body = body;
-    this.headers = {
-      ...this.headers,
-      "Content-Type": "text/plain"
-    };
-  }
-  /**
-   * Send a response with the given JSON, status defaults to 200
-   */
-  json(body) {
-    this.body = body;
-    this.headers = {
-      ...this.headers,
-      "Content-Type": "application/json"
-    };
-  }
-  /**
-   * Send a response with the given HTML, status defaults to 200
-   */
-  html(body) {
-    this.body = body;
-    this.headers = {
-      ...this.headers,
-      "Content-Type": "text/html"
-    };
-  }
-  /**
-   * Send a response with the given XML, status defaults to 200
-   */
-  xml(body) {
-    this.body = body;
-    this.headers = {
-      ...this.headers,
-      "Content-Type": "application/xml"
-    };
-  }
-  /**
-   * Send a response with the given binary with Content-Type of application/octet-stream header, status defaults to 200
-   */
-  download(body) {
-    this.body = body;
-    this.headers = {
-      ...this.headers,
-      "Content-Type": "application/octet-stream"
-    };
-  }
-  /**
-   * Send a response with the given file, status defaults to 200
-   */
-  file(pathToFile) {
-    const mimeType = getContentType(pathToFile);
-    const file = nativeFile.file(pathToFile);
-    this.headers = {
-      ...this.headers,
-      "Content-Type": mimeType
-    };
-  }
-  /**
-   * 2XX Success
-   */
-  /**
-   * 200 OK
-   */
-  ok(body) {
-    this.status(200).send(body);
-  }
-  /**
-   * 201 Created
-   */
-  created(body) {
-    this.status(201).send(body);
-  }
-  /**
-   * 202 Accepted
-   */
-  accepted(body) {
-    this.status(202).send(body);
-  }
-  /**
-   * 204 No Content
-   */
-  noContent() {
-    this.status(204).send("");
-  }
-  /**
-   * 206 Partial Content
-   */
-  partialContent(body) {
-    this.status(206).send(body);
-  }
-  /**
-   * 3XX Redirection
-   */
-  /**
-   * 300 Multiple Choices
-   */
-  multipleChoices(url) {
-    this.status(300).setHeader("Location", url);
-  }
-  redirect(url) {
-    this.status(302).setHeader("Location", url);
-  }
-  /**
-   * 301 Moved Permanently
-   */
-  movedPermanently(url) {
-    this.status(301).setHeader("Location", url);
-  }
-  /**
-   * 302 Found (Temporary Redirect)
-   */
-  found(url) {
-    this.status(302).setHeader("Location", url);
-  }
-  /**
-   * 303 See Other
-   */
-  seeOther(url) {
-    this.status(303).setHeader("Location", url);
-  }
-  /**
-   * 304 Not Modified
-   */
-  notModified() {
-    this.status(304).send("");
-  }
-  /**
-   * 307 Temporary Redirect
-   */
-  temporaryRedirect(url) {
-    this.status(307).setHeader("Location", url);
-  }
-  /**
-   * 308 Permanent Redirect
-   */
-  permanentRedirect(url) {
-    this.status(308).setHeader("Location", url);
-  }
-  /**
-   * 4XX Client Errors
-   */
-  /**
-   * 400 Bad Request
-   */
-  badRequest(body) {
-    this.status(400).send(body);
-  }
-  /**
-   * 401 Unauthorized
-   */
-  unauthorized(body) {
-    this.status(401).send(body);
-  }
-  /**
-   * 403 Forbidden
-   */
-  forbidden(body) {
-    this.status(403).send(body);
-  }
-  /**
-   * 404 Not Found
-   */
-  notFound(body) {
-    this.status(404).send(body);
-  }
-  /**
-   * 405 Method Not Allowed
-   */
-  methodNotAllowed(body) {
-    this.status(405).send(body);
-  }
-  /**
-   * 406 Not Acceptable
-   */
-  notAcceptable(body) {
-    this.status(406).send(body);
-  }
-  /**
-   * 409 Conflict
-   */
-  conflict(body) {
-    this.status(409).send(body);
-  }
-  /**
-   * 410 Gone
-   */
-  gone(body) {
-    this.status(410).send(body);
-  }
-  /**
-   * 413 Payload Too Large
-   */
-  payloadTooLarge(body) {
-    this.status(413).send(body);
-  }
-  /**
-   * 415 Unsupported Media Type
-   */
-  unsupportedMediaType(body) {
-    this.status(415).send(body);
-  }
-  /**
-   * 422 Unprocessable Entity
-   */
-  unprocessableEntity(body) {
-    this.status(422).send(body);
-  }
-  /**
-   * 429 Too Many Requests
-   */
-  tooManyRequests(body) {
-    this.status(429).send(body);
-  }
-  /**
-   * 5XX Server Errors
-   */
-  internalServerError(body) {
-    this.status(500).send(body);
-  }
-  /**
-   * 501 Not Implemented
-   */
-  notImplemented(body) {
-    this.status(501).send(body);
-  }
-  /**
-   * 502 Bad Gateway
-   */
-  badGateway(body) {
-    this.status(502).send(body);
-  }
-  /**
-   * 503 Service Unavailable
-   */
-  serviceUnavailable(body) {
-    this.status(503).send(body);
-  }
-  /**
-   * 504 Gateway Timeout
-   */
-  gatewayTimeout(body) {
-    this.status(504).send(body);
-  }
-  /**
-   * 505 HTTP Version Not Supported
-   */
-  httpVersionNotSupported(body) {
-    this.status(505).send(body);
-  }
-  /**
-   * Set a cookie for the response, does nothing if the cookie middleware is not registered
-   */
-  cookie(_name, _value, _options) {
-  }
-  /**
-   * Clear a cookie for the response, does nothing if the cookie middleware is not registered
-   */
-  clearCookie(_name, _options) {
-  }
-  /**
-   * Get the body of the response
-   */
-  getBody() {
-    return this.body;
-  }
-};
-
-// src/server/server.ts
-import { glob as glob2 } from "glob";
-import { join as join4 } from "path";
-
-// src/plugins/cookie/cookie.ts
-var cookie = (options) => {
-  const opts = {
-    secret: options?.secret ?? "",
-    defaults: {
-      path: "/",
-      httpOnly: true,
-      secure: false,
-      sameSite: "Lax",
-      ...options?.defaults
-    },
-    parse: options?.parse ?? true,
-    sign: options?.sign ?? false
-  };
-  return async (req, res, next) => {
-    if (opts.parse) {
-      const rawCookies = parseCookies(req.headers.get("cookie") || "");
-      req.cookies = {};
-      for (const [name, value] of Object.entries(rawCookies)) {
-        if (opts.sign && opts.secret) {
-          const verified = verifySignedCookie(value, opts.secret);
-          if (verified !== false) {
-            req.cookies[name] = verified;
-          }
-          continue;
-        }
-        req.cookies[name] = value;
-      }
-    }
-    res.cookie = (name, value, cookieOptions) => {
-      setCookie(res, name, value, { ...opts.defaults, ...cookieOptions }, opts);
-    };
-    res.clearCookie = (name, cookieOptions) => {
-      clearCookie(res, name, { ...opts.defaults, ...cookieOptions });
-    };
-    await next();
-  };
-};
-function parseCookies(cookieString) {
-  const cookies = {};
-  if (!cookieString) return cookies;
-  const pairs = cookieString.split(";");
-  for (const pair of pairs) {
-    const [name, value] = pair.trim().split("=");
-    if (name && value) {
-      cookies[decodeURIComponent(name)] = decodeURIComponent(value);
-    }
-  }
-  return cookies;
-}
-function setCookie(res, name, value, options, middlewareOptions) {
-  let cookieValue = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
-  if (options.domain) {
-    cookieValue += `; Domain=${options.domain}`;
-  }
-  if (options.path) {
-    cookieValue += `; Path=${options.path}`;
-  }
-  if (options.expires) {
-    cookieValue += `; Expires=${options.expires.toUTCString()}`;
-  }
-  if (options.maxAge) {
-    cookieValue += `; Max-Age=${options.maxAge}`;
-  }
-  if (options.secure) {
-    cookieValue += "; Secure";
-  }
-  if (options.httpOnly) {
-    cookieValue += "; HttpOnly";
-  }
-  if (options.sameSite) {
-    cookieValue += `; SameSite=${options.sameSite}`;
-  }
-  if (options.priority) {
-    cookieValue += `; Priority=${options.priority}`;
-  }
-  if (middlewareOptions.sign && middlewareOptions.secret) {
-    cookieValue = signCookie(cookieValue, middlewareOptions.secret);
-  }
-  const existingCookies = res.headers["set-cookie"] || "";
-  const newCookies = existingCookies ? `${existingCookies}, ${cookieValue}` : cookieValue;
-  res.setHeader("Set-Cookie", newCookies);
-}
-function clearCookie(res, name, options) {
-  const clearOptions = {
-    ...options,
-    expires: /* @__PURE__ */ new Date(0),
-    maxAge: 0
-  };
-  setCookie(res, name, "", clearOptions, {
-    secret: "",
-    defaults: {},
-    parse: true,
-    sign: false
-  });
-}
-function signCookie(value, secret) {
-  let hash = 0;
-  for (let i = 0; i < value.length; i++) {
-    const char = value.charCodeAt(i);
-    hash = (hash << 5) - hash + char;
-    hash = hash & hash;
-  }
-  const signature = Math.abs(hash).toString(36);
-  return `${value}.${signature}`;
-}
-function verifySignedCookie(value, secret) {
-  const parts = value.split(".");
-  if (parts.length !== 2) return false;
-  const [cookieValue, signature] = parts;
-  const expectedSignature = signCookie(cookieValue, secret).split(".")[1];
-  return signature === expectedSignature ? cookieValue : false;
-}
-
-// src/logger/logger.ts
-import pino from "pino";
-var createBaseLogger = () => {
-  const baseOptions = {
-    level: "info",
-    formatters: {
-      level: (label) => {
-        return { level: label };
-      }
-    }
-  };
-  return pino(baseOptions);
-};
-var logger = createBaseLogger();
-
-// src/plugins/log/log.ts
-var log = (options) => {
-  return async (req, res, next) => {
-    try {
-      const body = req.body;
-      if (options?.logRequest ?? true) {
-        logger.info({
-          type: "request",
-          requestId: req.id,
-          method: options?.requestPayload?.method ?? true ? req.method : void 0,
-          url: options?.requestPayload?.url ?? true ? req.url : void 0,
-          ip: options?.requestPayload?.ip ?? true ? req.ip : void 0,
-          headers: options?.requestPayload?.headers ?? true ? req.headers : void 0,
-          body: options?.requestPayload?.body ?? false ? returnIfObjectOrString(body) : void 0
-        });
-      }
-      await next();
-      if (options?.logResponse ?? true) {
-        logger.info({
-          type: "response",
-          requestId: req.id,
-          status: options?.responsePayload?.status ?? res.responseStatus,
-          body: options?.responsePayload?.body ?? false ? returnIfObjectOrString(res.getBody()) : void 0,
-          headers: options?.responsePayload?.headers ?? false ? res.headers : void 0
-        });
-      }
-    } catch (error) {
-      logger.error(error);
-      throw error;
-    }
-  };
-};
-function returnIfObjectOrString(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (value && typeof value === "object" && value.constructor === Object) {
-    return value;
-  }
-  return;
-}
-
-// src/plugins/rate_limiter/in_memory_storage.ts
-var InMemoryStorage = class {
-  storage = /* @__PURE__ */ new Map();
-  windowMs;
-  constructor(windowMs) {
-    this.windowMs = windowMs;
-  }
-  async set(key, value) {
-    this.storage.set(key, value);
-    setTimeout(() => {
-      this.storage.delete(key);
-    }, this.windowMs);
-  }
-  async get(key) {
-    const entry = this.storage.get(key);
-    if (!entry) {
-      return 0;
-    }
-    return entry;
-  }
-  async delete(key) {
-    this.storage.delete(key);
-  }
-};
-
-// src/plugins/rate_limiter/rate_limiter.ts
-var rateLimiter = (keyOptions, storageOptions) => {
-  const baseKeyOptions = {
-    type: "ip",
-    limit: 100,
-    message: "ERR_RATE_LIMIT_EXCEEDED",
-    statusCode: 429,
-    ...keyOptions
-  };
-  const baseStorageOptions = {
-    type: "memory",
-    ...storageOptions
-  };
-  if (baseStorageOptions.type === "memory" && !baseStorageOptions.windowMs) {
-    baseStorageOptions.windowMs = 6e4;
-  }
-  const storage = baseStorageOptions.type === "memory" ? new InMemoryStorage(baseStorageOptions.windowMs) : {
-    get: baseStorageOptions.get,
-    set: baseStorageOptions.set
-  };
-  return async (req, res, next) => {
-    const key = baseKeyOptions.type === "ip" ? req.ip : baseKeyOptions.key(req);
-    const value = await storage.get(key);
-    if (value >= baseKeyOptions.limit) {
-      return res.status(baseKeyOptions.statusCode).json({
-        message: baseKeyOptions.message
-      });
-    }
-    await storage.set(key, value + 1);
-    return next();
-  };
-};
-
-// src/runtime/native_server/server_utils.ts
-var executeMiddlewareChain = async (middlewares, handler, req, res = new Response2()) => {
-  let currentIndex = 0;
-  if (!middlewares.length) {
-    await handler(req, res);
-    return res;
-  }
-  const next = async () => {
-    currentIndex++;
-    if (currentIndex >= middlewares.length) {
-      await handler(req, res);
-      return;
-    }
-    const middleware2 = middlewares[currentIndex];
-    await middleware2(req, res, next);
-  };
-  const firstMiddleware = middlewares[0];
-  await firstMiddleware(req, res, next);
-  return res;
-};
-var canHaveBody = (method) => {
-  if (!method) {
-    return true;
-  }
-  return ["post", "put", "patch", "delete"].includes(method.toLowerCase());
-};
-
-// src/plugins/body_parser/body_parser.ts
-var bodyParser = () => {
-  return async (req, _res, next) => {
-    if (!canHaveBody(req.method)) {
-      return next();
-    }
-    req.rawBody = await req.arrayBuffer();
-    Object.defineProperty(req, "body", {
-      value: void 0,
-      writable: true,
-      configurable: true,
-      enumerable: true
-    });
-    return next();
-  };
-};
-
-// src/plugins/cors/cors.ts
-var cors = (options) => {
-  const opts = {
-    origin: "*",
-    methods: ["GET", "HEAD", "PUT", "PATCH", "POST", "DELETE"],
-    allowedHeaders: "",
-    exposedHeaders: "",
-    credentials: false,
-    maxAge: void 0,
-    preflightContinue: false,
-    optionsSuccessStatus: 204,
-    ...options
-  };
-  return async (req, res, next) => {
-    const requestOrigin = req.headers.get("origin") || "";
-    if (req.method === "OPTIONS") {
-      return handlePreflightRequest(req, res, opts, requestOrigin, next);
-    }
-    handleRegularRequest(req, res, opts, requestOrigin);
-    await next();
-  };
-};
-function handlePreflightRequest(_req, res, opts, requestOrigin, next) {
-  const allowOrigin = determineOrigin(opts, requestOrigin);
-  if (!allowOrigin) {
-    res.forbidden("CORS origin not allowed");
-    return;
-  }
-  setCorsHeaders(res, opts, allowOrigin);
-  if (opts.preflightContinue) {
-    next();
-    return;
-  }
-  res.status(opts.optionsSuccessStatus || 204);
-  res.send("");
-}
-function handleRegularRequest(_req, res, opts, requestOrigin) {
-  const allowOrigin = determineOrigin(opts, requestOrigin);
-  if (!allowOrigin) {
-    return;
-  }
-  setCorsHeaders(res, opts, allowOrigin);
-}
-function determineOrigin(opts, requestOrigin) {
-  if (typeof opts.origin === "string") {
-    return opts.origin;
-  }
-  if (Array.isArray(opts.origin)) {
-    const matchedOrigin = opts.origin.find(
-      (origin) => typeof origin === "string" ? origin === requestOrigin : origin instanceof RegExp && origin.test(requestOrigin)
-    );
-    return typeof matchedOrigin === "string" ? matchedOrigin : false;
-  }
-  return "*";
-}
-function setCorsHeaders(res, opts, allowOrigin) {
-  res.setHeader("Access-Control-Allow-Origin", allowOrigin);
-  if (opts.credentials) {
-    res.setHeader("Access-Control-Allow-Credentials", "true");
-  }
-  if (opts.exposedHeaders && opts.exposedHeaders !== "") {
-    const exposedHeaders = Array.isArray(opts.exposedHeaders) ? opts.exposedHeaders.join(",") : opts.exposedHeaders;
-    res.setHeader("Access-Control-Expose-Headers", exposedHeaders);
-  }
-  if (opts.allowedHeaders && opts.allowedHeaders !== "") {
-    const allowedHeaders = Array.isArray(opts.allowedHeaders) ? opts.allowedHeaders.join(",") : opts.allowedHeaders;
-    res.setHeader("Access-Control-Allow-Headers", allowedHeaders);
-  }
-  const methodsStr = Array.isArray(opts.methods) ? opts.methods.join(",") : opts.methods;
-  res.setHeader("Access-Control-Allow-Methods", String(methodsStr || ""));
-  if (typeof opts.maxAge === "number") {
-    res.setHeader("Access-Control-Max-Age", opts.maxAge.toString());
-  }
-}
-
-// src/plugins/file/file.ts
-import { tmpdir } from "os";
-import { extname as extname2, join as join3 } from "path";
-
-// src/errors/file_too_large.ts
-var FileTooLargeError = class extends BaldaError {
-  constructor(filename, size, maxSize) {
-    super(
-      `FILE_TOO_LARGE: "${filename}" is too large. Max size is ${maxSize} bytes, but got ${size} bytes`
-    );
-  }
-};
-
-// src/plugins/file/file.ts
-var fileParser = (options) => {
-  return async (req, res, next) => {
-    const tmpPaths = [];
-    try {
-      const contentType = req.headers.get("content-type") ?? req.headers.get("Content-Type");
-      if (!contentType || !contentType.startsWith("multipart/form-data")) {
-        return next();
-      }
-      if (!req.rawBody) {
-        return next();
-      }
-      const boundaryMatch = contentType.match(/boundary=(.*)(;|$)/i);
-      if (!boundaryMatch) {
-        return next();
-      }
-      const boundary = boundaryMatch[1].replace(/(^\s*"?|"?\s*$)/g, "");
-      const bodyBuf = new Uint8Array(req.rawBody);
-      const boundaryBuf = new TextEncoder().encode(`--${boundary}`);
-      const CRLFCRLF = new Uint8Array([13, 10, 13, 10]);
-      const parts = [];
-      const indexOfSub = (haystack, needle, from = 0) => {
-        outer: for (let i = from; i <= haystack.length - needle.length; i++) {
-          for (let j = 0; j < needle.length; j++) {
-            if (haystack[i + j] !== needle[j]) continue outer;
-          }
-          return i;
-        }
-        return -1;
-      };
-      let start = indexOfSub(bodyBuf, boundaryBuf);
-      while (start !== -1) {
-        start += boundaryBuf.length;
-        if (bodyBuf[start] === 45 && bodyBuf[start + 1] === 45) {
-          break;
-        }
-        if (bodyBuf[start] === 13 && bodyBuf[start + 1] === 10) {
-          start += 2;
-        }
-        const headerEnd = indexOfSub(bodyBuf, CRLFCRLF, start);
-        if (headerEnd === -1) {
-          break;
-        }
-        const headersBuf = bodyBuf.subarray(start, headerEnd);
-        const headers = new TextDecoder().decode(headersBuf);
-        const dataStart = headerEnd + CRLFCRLF.length;
-        const nextBoundary = indexOfSub(bodyBuf, boundaryBuf, dataStart);
-        if (nextBoundary === -1) {
-          break;
-        }
-        let dataEnd = nextBoundary - 1;
-        if (bodyBuf[dataEnd] === 10) {
-          dataEnd--;
-        }
-        if (bodyBuf[dataEnd] === 13) {
-          dataEnd--;
-        }
-        const data = bodyBuf.subarray(dataStart, dataEnd + 1);
-        parts.push({ headers, data });
-        start = nextBoundary;
-      }
-      const files = [];
-      const fields = {};
-      for (const part of parts) {
-        const disposition = part.headers.split("\r\n").find((h) => h.toLowerCase().startsWith("content-disposition:"));
-        if (!disposition) {
-          continue;
-        }
-        const formNameMatch = disposition.match(/name="([^"]+)"/);
-        if (!formNameMatch) {
-          continue;
-        }
-        const formName = formNameMatch[1];
-        const filenameMatch = disposition.match(/filename="([^"]*)"/);
-        const originalName = filenameMatch ? filenameMatch[1] : "";
-        const isFile = Boolean(originalName);
-        if (isFile) {
-          if (options?.maxFileSize && part.data.length > options.maxFileSize) {
-            return res.badRequest({
-              ...errorFactory(
-                new FileTooLargeError(
-                  originalName,
-                  part.data.length,
-                  options.maxFileSize
-                )
-              )
-            });
-          }
-          const contentTypeHeader = part.headers.split("\r\n").find((h) => h.toLowerCase().startsWith("content-type:"));
-          const mimeType = contentTypeHeader ? contentTypeHeader.split(":")[1].trim() : "application/octet-stream";
-          const extension = extname2(originalName);
-          const tmpPath = join3(tmpdir(), `${randomString(10)}${extension}`);
-          await nativeFs.writeFile(tmpPath, part.data);
-          tmpPaths.push(tmpPath);
-          files.push({
-            formName,
-            mimeType,
-            size: part.data.length,
-            tmpPath,
-            originalName
-          });
-        } else {
-          fields[formName] = new TextDecoder().decode(part.data);
-        }
-      }
-      req.files = files;
-      req.body = fields;
-      await next();
-      await cleanupTmpFiles(tmpPaths);
-    } catch (error) {
-      await cleanupTmpFiles(tmpPaths);
-      throw error;
-    }
-  };
-};
-async function cleanupTmpFiles(paths) {
-  await Promise.allSettled(paths.map((path) => nativeFs.unlink(path)));
-}
-function randomString(length) {
-  return Math.random().toString(36).substring(2, 2 + length);
-}
-
-// src/plugins/helmet/helmet.ts
-var helmet = (options) => {
-  const opts = {
-    dnsPrefetchControl: true,
-    frameguard: { action: "SAMEORIGIN" },
-    hsts: { maxAge: 15552e3, includeSubDomains: true, preload: false },
-    contentTypeOptions: true,
-    ieNoOpen: true,
-    xssFilter: true,
-    referrerPolicy: "no-referrer",
-    crossOriginResourcePolicy: "same-origin",
-    crossOriginOpenerPolicy: "same-origin",
-    crossOriginEmbedderPolicy: "require-corp",
-    contentSecurityPolicy: false,
-    ...options
-  };
-  return async (_req, res, next) => {
-    if (opts.dnsPrefetchControl) {
-      res.setHeader("X-DNS-Prefetch-Control", "off");
-    }
-    if (opts.frameguard) {
-      let action = "SAMEORIGIN";
-      if (typeof opts.frameguard === "object") {
-        action = opts.frameguard.action;
-      }
-      res.setHeader("X-Frame-Options", action);
-    }
-    if (opts.hsts) {
-      let hstsRaw = {};
-      if (typeof opts.hsts === "object") {
-        hstsRaw = opts.hsts;
-      }
-      const maxAge = hstsRaw.maxAge !== void 0 ? hstsRaw.maxAge : 15552e3;
-      const includeSubDomains = hstsRaw.includeSubDomains !== void 0 ? hstsRaw.includeSubDomains : true;
-      const preload = hstsRaw.preload !== void 0 ? hstsRaw.preload : false;
-      let hstsValue = `max-age=${maxAge}`;
-      if (includeSubDomains !== false) {
-        hstsValue += "; includeSubDomains";
-      }
-      if (preload) {
-        hstsValue += "; preload";
-      }
-      res.setHeader("Strict-Transport-Security", hstsValue);
-    }
-    if (opts.contentTypeOptions) {
-      res.setHeader("X-Content-Type-Options", "nosniff");
-    }
-    if (opts.ieNoOpen) {
-      res.setHeader("X-Download-Options", "noopen");
-    }
-    if (opts.xssFilter) {
-      res.setHeader("X-XSS-Protection", "0");
-    }
-    if (opts.referrerPolicy) {
-      res.setHeader("Referrer-Policy", opts.referrerPolicy);
-    }
-    if (opts.crossOriginResourcePolicy) {
-      res.setHeader(
-        "Cross-Origin-Resource-Policy",
-        opts.crossOriginResourcePolicy
-      );
-    }
-    if (opts.crossOriginOpenerPolicy) {
-      res.setHeader("Cross-Origin-Opener-Policy", opts.crossOriginOpenerPolicy);
-    }
-    if (opts.crossOriginEmbedderPolicy) {
-      res.setHeader(
-        "Cross-Origin-Embedder-Policy",
-        opts.crossOriginEmbedderPolicy
-      );
-    }
-    if (opts.contentSecurityPolicy) {
-      res.setHeader("Content-Security-Policy", opts.contentSecurityPolicy);
-    }
-    await next();
-  };
-};
-
-// src/errors/json_not_valid.ts
-var JsonNotValidError = class extends BaldaError {
-  constructor(json2) {
-    super(`JSON_NOT_VALID: "${JSON.stringify(json2)}" is not a valid JSON`);
-  }
-};
-
-// src/plugins/json/json.ts
-var json = (options) => {
-  return async (req, res, next) => {
-    if (!isJsonRequest(req) || !canHaveBody(req.method)) {
-      return next();
-    }
-    const sizeLimit = options?.sizeLimit ?? 5 * 1024 * 1024;
-    const arrayBuffer = req.rawBody;
-    if (!arrayBuffer) {
-      if (options?.parseEmptyBodyAsObject) {
-        req.body = {};
-      }
-      return next();
-    }
-    const byteLength = arrayBuffer.byteLength;
-    if (!byteLength) {
-      if (options?.parseEmptyBodyAsObject) {
-        req.body = {};
-      }
-      return next();
-    }
-    if (byteLength > sizeLimit) {
-      const customErrorMessage = {
-        status: 413,
-        message: "ERR_REQUEST_BODY_TOO_LARGE",
-        ...options?.customErrorMessage
-      };
-      return res.status(customErrorMessage.status).json({
-        error: customErrorMessage.message
-      });
-    }
-    try {
-      const encoding = options?.encoding ?? "utf-8";
-      const decodedBody = new TextDecoder(encoding).decode(arrayBuffer);
-      req.body = JSON.parse(decodedBody);
-    } catch (error) {
-      if (error instanceof SyntaxError) {
-        return res.badRequest({
-          ...errorFactory(new JsonNotValidError("Invalid JSON syntax"))
-        });
-      }
-      return res.badRequest({
-        ...errorFactory(new JsonNotValidError("Invalid request body encoding"))
-      });
-    }
-    await next();
-  };
-};
-function isJsonRequest(req) {
-  const contentType = getContentType2(req);
-  if (!contentType) {
-    return false;
-  }
-  const mimeType = parseMimeType(contentType);
-  return mimeType === "application/json";
-}
-function getContentType2(req) {
-  const contentType = req.headers.get("content-type") ?? req.headers.get("Content-Type");
-  if (!contentType) {
-    return null;
-  }
-  if (Array.isArray(contentType)) {
-    return contentType[0] || null;
-  }
-  return contentType;
-}
-function parseMimeType(contentType) {
-  const trimmed = contentType.trim();
-  const semicolonIndex = trimmed.indexOf(";");
-  if (semicolonIndex === -1) {
-    return trimmed.toLowerCase();
-  }
-  return trimmed.substring(0, semicolonIndex).trim().toLowerCase();
-}
-
-// src/plugins/swagger/swagger.ts
-var swagger = (globalOptions) => {
-  let swaggerOptions = {
-    type: "standard",
-    path: "/docs",
-    title: "Balda API Documentation",
-    description: "API Documentation from the Balda Framework",
-    version: "1.0.0",
-    servers: ["http://localhost"],
-    security: [],
-    tags: [],
-    components: {},
-    securitySchemes: {},
-    models: {}
-  };
-  if (typeof globalOptions !== "boolean") {
-    swaggerOptions = {
-      ...swaggerOptions,
-      ...globalOptions
-    };
-  }
-  const spec = generateOpenAPISpec(swaggerOptions);
-  const uiPath = `${swaggerOptions.path}`;
-  const jsonPath = `${uiPath}/json`;
-  const uiContent = swaggerOptions.type === "redoc" ? generateRedocUI(jsonPath, swaggerOptions) : swaggerOptions.type === "rapidoc" ? generateRapiDocUI(jsonPath, swaggerOptions) : generateSwaggerUI(jsonPath, swaggerOptions);
-  router.addOrUpdate("GET", uiPath, [], (_req, res) => {
-    res.html(uiContent);
-  });
-  router.addOrUpdate("GET", jsonPath, [], (_req, res) => {
-    res.json(spec);
-  });
-};
-function generateOpenAPISpec(globalOptions) {
-  const routes = router.getRoutes();
-  const paths = {};
-  const components = {
-    ...globalOptions.components,
-    securitySchemes: globalOptions.securitySchemes || {},
-    schemas: globalOptions.models ? {
-      ...globalOptions.components?.schemas || {},
-      ...globalOptions.models
-    } : globalOptions.components?.schemas ? { ...globalOptions.components.schemas } : void 0
-  };
-  for (const route of routes) {
-    const swaggerOptions = route.swaggerOptions;
-    if (swaggerOptions?.excludeFromSwagger) continue;
-    if (!paths[route.path]) paths[route.path] = {};
-    const method = route.method.toLowerCase();
-    const operation = {
-      summary: swaggerOptions?.name || `${method.toUpperCase()} ${route.path}`,
-      description: swaggerOptions?.description || "",
-      tags: swaggerOptions?.service ? [swaggerOptions.service] : [],
-      deprecated: swaggerOptions?.deprecated || false
-    };
-    let parameters = [];
-    if (swaggerOptions?.query) {
-      if (swaggerOptions.query.type === "object" && swaggerOptions.query.properties) {
-        for (const [name, schema] of Object.entries(
-          swaggerOptions.query.properties
-        )) {
-          parameters.push({
-            name,
-            in: "query",
-            required: Array.isArray(swaggerOptions.query.required) ? swaggerOptions.query.required.includes(name) : false,
-            schema: typeboxToOpenAPI(schema)
-          });
-        }
-      }
-    }
-    if (swaggerOptions && swaggerOptions.params) {
-      parameters = parameters.concat(
-        extractPathParams(route.path, swaggerOptions.params)
-      );
-    } else {
-      parameters = parameters.concat(extractPathParams(route.path));
-    }
-    if (parameters.length > 0) {
-      operation.parameters = parameters;
-    }
-    if (swaggerOptions?.requestBody) {
-      let routeBodyContentType = "application/json";
-      if (swaggerOptions.bodyType === "form-data") {
-        routeBodyContentType = "multipart/form-data";
-      } else if (swaggerOptions.bodyType === "urlencoded") {
-        routeBodyContentType = "application/x-www-form-urlencoded";
-      }
-      operation.requestBody = {
-        content: {
-          [routeBodyContentType]: {
-            schema: typeboxToOpenAPI(swaggerOptions.requestBody)
-          }
-        },
-        required: true
-      };
-    } else if (swaggerOptions?.bodyType && (swaggerOptions.bodyType.includes("form-data") || swaggerOptions.bodyType.includes("urlencoded"))) {
-      operation.requestBody = {
-        content: {
-          [swaggerOptions.bodyType]: {
-            schema: { type: "object" }
-          }
-        },
-        required: true
-      };
-    }
-    operation.responses = {};
-    if (swaggerOptions?.responses) {
-      for (const [statusCode, schema] of Object.entries(
-        swaggerOptions.responses
-      )) {
-        operation.responses[statusCode] = {
-          description: `Response for ${statusCode}`,
-          content: {
-            "application/json": {
-              schema: typeboxToOpenAPI(schema)
-            }
-          }
-        };
-      }
-    }
-    if (swaggerOptions?.errors) {
-      for (const [statusCode, schema] of Object.entries(
-        swaggerOptions.errors
-      )) {
-        operation.responses[statusCode] = {
-          description: `Error response for ${statusCode}`,
-          content: {
-            "application/json": {
-              schema: typeboxToOpenAPI(schema)
-            }
-          }
-        };
-      }
-    }
-    if (Object.keys(operation.responses).length === 0) {
-      operation.responses["200"] = {
-        description: "Successful response",
-        content: {
-          "application/json": {
-            schema: { type: "object" }
-          }
-        }
-      };
-    }
-    if (swaggerOptions?.security) {
-      const securityArr = [];
-      if (!Array.isArray(swaggerOptions.security)) {
-        swaggerOptions.security = [swaggerOptions.security];
-      }
-      for (const sec of swaggerOptions.security) {
-        if (sec.type === "bearer") {
-          if (!components.securitySchemes.bearer) {
-            components.securitySchemes.bearer = {
-              type: "http",
-              scheme: "bearer",
-              bearerFormat: sec.bearerFormat || "JWT",
-              description: sec.description
-            };
-          }
-          securityArr.push({ bearer: [] });
-        } else if (sec.type === "apiKey") {
-          if (!components.securitySchemes[sec.name]) {
-            components.securitySchemes[sec.name] = {
-              type: "apiKey",
-              name: sec.name,
-              in: sec.in,
-              description: sec.description
-            };
-          }
-          securityArr.push({ [sec.name]: [] });
-        } else if (sec.type === "oauth2") {
-          const schemeName = sec.name || "oauth2";
-          if (!components.securitySchemes[schemeName]) {
-            components.securitySchemes[schemeName] = {
-              type: "oauth2",
-              flows: sec.flows,
-              description: sec.description
-            };
-          }
-          securityArr.push({ [schemeName]: [] });
-        } else if (sec.type === "openIdConnect") {
-          const schemeName = sec.name || "openIdConnect";
-          if (!components.securitySchemes[schemeName]) {
-            components.securitySchemes[schemeName] = {
-              type: "openIdConnect",
-              openIdConnectUrl: sec.openIdConnectUrl,
-              description: sec.description
-            };
-          }
-          securityArr.push({ [schemeName]: [] });
-        }
-      }
-      if (securityArr.length) operation.security = securityArr;
-    } else if (globalOptions.security) {
-      operation.security = globalOptions.security;
-    }
-    paths[route.path][method] = operation;
-  }
-  return {
-    openapi: "3.0.0",
-    info: {
-      title: globalOptions.title,
-      description: globalOptions.description,
-      version: globalOptions.version,
-      ...globalOptions.info
-    },
-    servers: globalOptions.servers?.map((url) => ({ url })) || [{ url: "/" }],
-    paths,
-    components,
-    security: globalOptions.security || [],
-    tags: globalOptions.tags ? Object.entries(globalOptions.tags).map(([name, config]) => ({
-      name,
-      ...config
-    })) : []
-  };
-}
-function generateSwaggerUI(specUrl, globalOptions) {
-  return `
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <meta name="description" content="${globalOptions.description}" />
-    <title>${globalOptions.title}</title>
-    <link rel="stylesheet" type="text/css" href="https://unpkg.com/swagger-ui-dist@5.9.0/swagger-ui.css" />
-    <style>
-        html {
-            box-sizing: border-box;
-            overflow: -moz-scrollbars-vertical;
-            overflow-y: scroll;
-        }
-        *, *:before, *:after {
-            box-sizing: inherit;
-        }
-        body {
-            margin:0;
-            background: #fafafa;
-        }
-    </style>
-</head>
-<body>
-    <div id="swagger-ui"></div>
-    <script src="https://unpkg.com/swagger-ui-dist@5.9.0/swagger-ui-bundle.js"></script>
-    <script src="https://unpkg.com/swagger-ui-dist@5.9.0/swagger-ui-standalone-preset.js"></script>
-    <script>
-        window.onload = function() {
-            const ui = SwaggerUIBundle({
-                url: '${specUrl}',
-                dom_id: '#swagger-ui',
-                deepLinking: true,
-                presets: [
-                    SwaggerUIBundle.presets.apis,
-                    SwaggerUIStandalonePreset
-                ],
-                plugins: [
-                    SwaggerUIBundle.plugins.DownloadUrl
-                ],
-                layout: "StandaloneLayout",
-                validatorUrl: null,
-                oauth2RedirectUrl: window.location.origin + '/swagger-ui/oauth2-redirect.html'
-            });
-        };
-    </script>
-</body>
-</html>`;
-}
-function generateRedocUI(specUrl, globalOptions) {
-  return `
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>${globalOptions.title}</title>
-    <meta charset="utf-8"/>
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <meta name="description" content="${globalOptions.description}" />
-    <link rel="icon" type="image/png" href="https://redocly.github.io/redoc/favicon.ico">
-    <style>
-      body { margin: 0; padding: 0; }
-    </style>
-  </head>
-  <body>
-    <redoc spec-url="${specUrl}"></redoc>
-    <script src="https://cdn.jsdelivr.net/npm/redoc@next/bundles/redoc.standalone.js"></script>
-  </body>
-</html>
-  `;
-}
-function generateRapiDocUI(specUrl, globalOptions) {
-  return `
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>${globalOptions.title}</title>
-    <meta charset="utf-8"/>
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <meta name="description" content="${globalOptions.description}" />
-    <link rel="icon" type="image/png" href="https://mrin9.github.io/RapiDoc/images/favicon.png">
-    <style>
-      body { margin: 0; padding: 0; }
-    </style>
-  </head>
-  <body>
-    <rapi-doc
-      spec-url="${specUrl}"
-      render-style="read"
-      layout="column"
-      show-header="true"
-      allow-server-selection="true"
-      allow-authentication="true"
-      allow-server-variables="true"
-      theme="light"
-      primary-color="#009688"
-      regular-font="Open Sans, sans-serif"
-      mono-font="Fira Mono, monospace"
-      >
-    </rapi-doc>
-    <script type="module" src="https://unpkg.com/rapidoc/dist/rapidoc-min.js"></script>
-  </body>
-</html>
-  `;
-}
-function typeboxToOpenAPI(schema) {
-  if (!schema) {
-    return void 0;
-  }
-  const { $id, $schema, ...rest } = schema;
-  return rest;
-}
-function extractPathParams(path, paramSchema) {
-  const params = [];
-  const regex = /:([a-zA-Z0-9_]+)/g;
-  let match;
-  while ((match = regex.exec(path)) !== null) {
-    const name = match[1];
-    let schema = { type: "string" };
-    if (paramSchema && paramSchema.type === "object" && paramSchema.properties && paramSchema.properties[name]) {
-      schema = typeboxToOpenAPI(paramSchema.properties[name]) || {
-        type: "string"
-      };
-    }
-    params.push({
-      name,
-      in: "path",
-      required: true,
-      schema
-    });
-  }
-  return params;
-}
-
-// src/runtime/native_server/server_bun.ts
-var ServerBun = class {
-  port;
-  hostname;
-  host;
-  routes;
-  tapOptions;
-  constructor(input) {
-    this.routes = input?.routes ?? [];
-    this.port = input?.port ?? 80;
-    this.hostname = input?.host ?? "0.0.0.0";
-    this.host = input?.host ?? "0.0.0.0";
-    this.tapOptions = input?.tapOptions;
-  }
-  listen() {
-    const tapOptions = this.tapOptions?.options;
-    const { fetch, ...rest } = tapOptions ?? {};
-    this.runtimeServer = Bun.serve({
-      port: this.port,
-      hostname: this.hostname,
-      fetch: async (req, server) => {
-        const url = new URL(req.url);
-        const match = router.find(req.method, url.pathname);
-        Request2.enrichRequest(req);
-        req.params = match?.params ?? {};
-        req.query = Object.fromEntries(url.searchParams.entries());
-        req.ip = req.headers.get("x-forwarded-for")?.split(",")[0] ?? server.requestIP(req)?.address;
-        await fetch?.call(this, req, server);
-        const response = await executeMiddlewareChain(
-          match?.middleware ?? [],
-          match?.handler ?? ((req2, res) => {
-            res.notFound({
-              ...errorFactory(new RouteNotFoundError(req2.url, req2.method))
-            });
-          }),
-          req
-        );
-        const responseHeaders = response.headers;
-        if (responseHeaders["Content-Type"] === "application/json") {
-          return Response.json(response.getBody(), {
-            status: response.responseStatus,
-            headers: response.headers
-          });
-        }
-        return new Response(response.getBody(), {
-          status: response.responseStatus,
-          headers: response.headers
-        });
-      },
-      ...rest
-    });
-    this.url = this.runtimeServer.url.toString();
-  }
-  async close() {
-    if (!this.runtimeServer) {
-      throw new Error("Server is not listening or not initialized");
-    }
-    await this.runtimeServer.stop();
-  }
-};
-
-// src/runtime/native_server/server_deno.ts
-var ServerDeno = class {
-  constructor(input) {
-    this.routes = input?.routes ?? [];
-    this.port = input?.port ?? 80;
-    this.hostname = input?.host ?? "0.0.0.0";
-    this.host = input?.host ?? "0.0.0.0";
-    this.tapOptions = input?.tapOptions;
-  }
-  listen() {
-    const tapOptions = this.tapOptions?.options;
-    const { handler, ...rest } = tapOptions ?? {};
-    this.runtimeServer = Deno.serve({
-      port: this.port,
-      hostname: this.hostname,
-      handler: async (req, info) => {
-        const url = new URL(req.url);
-        const match = router.find(req.method, url.pathname);
-        Request2.enrichRequest(req);
-        req.params = match?.params ?? {};
-        req.query = Object.fromEntries(url.searchParams.entries());
-        req.ip = req.headers.get("x-forwarded-for")?.split(",")[0] ?? info.remoteAddr?.hostname;
-        await handler?.(req, info);
-        const res = await executeMiddlewareChain(
-          match?.middleware ?? [],
-          match?.handler ?? ((req2, res2) => {
-            res2.notFound({
-              ...errorFactory(new RouteNotFoundError(req2.url, req2.method))
-            });
-          }),
-          req
-        );
-        const responseHeaders = res.headers;
-        if (responseHeaders["Content-Type"] === "application/json") {
-          return Response.json(res.getBody(), {
-            status: res.responseStatus,
-            headers: res.headers
-          });
-        }
-        return new Response(res.getBody(), {
-          status: res.responseStatus,
-          headers: res.headers
-        });
-      },
-      ...rest
-    });
-    this.url = `http://${this.host}:${this.port}`;
-  }
-  async close() {
-    if (!this.runtimeServer) {
-      throw new Error("Server is not listening or not initialized");
-    }
-    await this.runtimeServer.shutdown();
-  }
-};
-
-// src/runtime/native_server/server_node.ts
-import {
-  createServer
-} from "http";
-async function pipeReadableStreamToNodeResponse(stream, res) {
-  const reader = stream.getReader();
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        res.end();
-        break;
-      }
-      res.write(value);
-    }
-  } catch (error) {
-    res.destroy(error);
-  }
-}
-var ServerNode = class {
-  port;
-  host;
-  url;
-  routes;
-  tapOptions;
-  runtimeServer;
-  constructor(input) {
-    this.routes = input?.routes ?? [];
-    this.port = input?.port ?? 80;
-    this.host = input?.host ?? "0.0.0.0";
-    this.url = `http://${this.host}:${this.port}`;
-    this.tapOptions = input?.tapOptions;
-    this.runtimeServer = createServer(
-      async (req, httpResponse) => {
-        if (this.tapOptions) {
-          const { options } = this.tapOptions;
-          await options?.(req);
-        }
-        const match = router.find(req.method, req.url);
-        const request = new Request2(`${this.url}${req.url}`, {
-          method: req.method,
-          body: canHaveBody(req.method) ? await this.readRequestBody(req) : void 0,
-          headers: req.headers
-        });
-        let forwardedFor = req.headers["x-forwarded-for"];
-        if (Array.isArray(forwardedFor)) {
-          forwardedFor = forwardedFor[0];
-        }
-        request.ip = forwardedFor ?? req.socket.remoteAddress;
-        const [_, search = ""] = req.url?.split("?", 2) ?? [];
-        request.query = Object.fromEntries(new URLSearchParams(search));
-        request.params = match?.params ?? {};
-        const response = await executeMiddlewareChain(
-          match?.middleware ?? [],
-          match?.handler ?? ((req2, res) => {
-            res.notFound({
-              ...errorFactory(new RouteNotFoundError(req2.url, req2.method))
-            });
-          }),
-          request
-        );
-        let body = response.getBody();
-        if (body instanceof ReadableStream) {
-          pipeReadableStreamToNodeResponse(body, httpResponse);
-          return;
-        }
-        if (response.headers["Content-Type"] === "application/json") {
-          body = JSON.stringify(body);
-        } else if (typeof body === "string") {
-          body = body;
-        } else if (body instanceof Buffer || body instanceof Uint8Array) {
-          body = body;
-        } else {
-          body = String(body);
-        }
-        httpResponse.writeHead(response.responseStatus, response.headers);
-        httpResponse.end(body);
-      }
-    );
-  }
-  listen() {
-    this.runtimeServer.listen(this.port, this.host);
-  }
-  async close() {
-    return new Promise((resolve2, reject) => {
-      this.runtimeServer.close((err) => {
-        if (err && "code" in err && err.code !== "ERR_SERVER_NOT_RUNNING") {
-          reject(err);
-        } else {
-          resolve2();
-        }
-      });
-    });
-  }
-  async readRequestBody(req) {
-    return new Promise((resolve2, reject) => {
-      const chunks = [];
-      req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
-      req.on("error", reject);
-      req.on("end", () => resolve2(Buffer.concat(chunks).toString()));
-    });
-  }
-};
-
-// src/runtime/native_server/server_connector.ts
-var ServerConnector = class {
-  server;
-  constructor(serverOptions) {
-    this.server = this.getRuntimeServer(serverOptions);
-    this.routes = this.server.routes;
-  }
-  get url() {
-    return this.server.url;
-  }
-  get port() {
-    return this.server.port;
-  }
-  get host() {
-    return this.server.host;
-  }
-  /**
-   * Get the server for the given runtime
-   * @example "node" returns HttpServer
-   * @example "bun" returns ReturnType<typeof Bun.serve>
-   * @example "deno" returns ReturnType<typeof Deno.serve>
-   * @param _ - The runtime to get the server for
-   * @returns The server for the given runtime
-   */
-  getServer(_) {
-    return this.server.runtimeServer;
-  }
-  listen() {
-    return this.server.listen();
-  }
-  close() {
-    return this.server.close();
-  }
-  getRuntimeServer(serverOptions) {
-    if (serverOptions?.runtime === "bun") {
-      return new ServerBun(serverOptions);
-    } else if (serverOptions?.runtime === "node") {
-      return new ServerNode(serverOptions);
-    } else if (serverOptions?.runtime === "deno") {
-      return new ServerDeno(serverOptions);
-    }
-    throw new Error(
-      "No server implementation found for runtime: " + serverOptions?.runtime
-    );
-  }
-};
-
-// src/server/server_constants.ts
-var PROTECTED_KEYS = [
-  "isListening",
-  "url",
-  "port",
-  "host",
-  "routes",
-  "embed",
-  "constructor",
-  "get",
-  "post",
-  "put",
-  "patch",
-  "delete",
-  "getNodeServer",
-  "getBunServer",
-  "getDenoServer",
-  "use",
-  "setErrorHandler",
-  "listen",
-  "close",
-  "tapOptions",
-  "startUpOptions",
-  "tmpDir",
-  "logger",
-  "getMockServer"
-];
-
-// src/mock/mock_response.ts
-var MockResponse = class {
-  constructor(response) {
-    this.response = response;
-  }
-  // base getters
-  body() {
-    return this.response.getBody();
-  }
-  statusCode() {
-    return this.response.responseStatus;
-  }
-  headers() {
-    return this.response.headers;
-  }
-  // assertions
-  assertStatus(status) {
-    if (this.response.responseStatus !== status) {
-      throw new Error(
-        `Expected status ${status}, but got ${this.response.responseStatus}`
-      );
-    }
-    return this;
-  }
-  assertHeader(header, value) {
-    if (this.response.headers[header] !== value) {
-      throw new Error(
-        `Expected header ${header} to be ${value}, but got ${this.response.headers[header]}`
-      );
-    }
-    return this;
-  }
-  assertHeaderExists(header) {
-    if (!(header in this.response.headers)) {
-      throw new Error(
-        `Expected header ${header} to exist, but it was not found`
-      );
-    }
-    return this;
-  }
-  assertHeaderNotExists(header) {
-    if (header in this.response.headers) {
-      throw new Error(
-        `Expected header ${header} to not exist, but it was found with value: ${this.response.headers[header]}`
-      );
-    }
-    return this;
-  }
-  // TODO: body assertions
-  assertBodySubset(subset) {
-    this.assertSubset(this.body(), subset, "body");
-    return this;
-  }
-  assertBodyDeepEqual(expected) {
-    this.assertDeepEqual(this.body(), expected, "body");
-    return this;
-  }
-  assertBodyNotSubset(subset) {
-    this.assertNotSubset(this.body(), subset, "body");
-    return this;
-  }
-  assertBodyNotDeepEqual(expected) {
-    this.assertNotDeepEqual(this.body(), expected, "body");
-    return this;
-  }
-  assertCustom(assertion) {
-    assertion(this.response);
-    return this;
-  }
-  assertSubset(target, subset, path) {
-    for (const key in subset) {
-      const currentPath = path === "" ? key : `${path}.${key}`;
-      const targetValue = target[key];
-      const subsetValue = subset[key];
-      if (!(key in target)) {
-        throw new Error(
-          `Expected ${path} to have key ${key}, but it was not found`
-        );
-      }
-      if (this.isObject(subsetValue) && this.isObject(targetValue)) {
-        this.assertSubset(targetValue, subsetValue, currentPath);
-      } else if (Array.isArray(subsetValue) && Array.isArray(targetValue)) {
-        this.assertArraySubset(targetValue, subsetValue, currentPath);
-      } else if (targetValue !== subsetValue) {
-        throw new Error(
-          `Expected ${currentPath} to be ${subsetValue}, but got ${targetValue}`
-        );
-      }
-    }
-  }
-  assertDeepEqual(target, expected, path) {
-    if (this.isObject(target) && this.isObject(expected)) {
-      const targetKeys = Object.keys(target);
-      const expectedKeys = Object.keys(expected);
-      if (targetKeys.length !== expectedKeys.length) {
-        throw new Error(
-          `Expected ${path} to have ${expectedKeys.length} keys, but got ${targetKeys.length}`
-        );
-      }
-      for (const key of expectedKeys) {
-        const currentPath = path === "body" ? key : `${path}.${key}`;
-        this.assertDeepEqual(target[key], expected[key], currentPath);
-      }
-    } else if (Array.isArray(target) && Array.isArray(expected)) {
-      this.assertArrayDeepEqual(target, expected, path);
-    } else if (target !== expected) {
-      throw new Error(`Expected ${path} to be ${expected}, but got ${target}`);
-    }
-  }
-  assertNotSubset(target, subset, path) {
-    try {
-      this.assertSubset(target, subset, path);
-      throw new Error(
-        `Expected ${path} to NOT contain the subset, but it does`
-      );
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("Expected")) {
-        return;
-      }
-      throw error;
-    }
-  }
-  assertNotDeepEqual(target, expected, path) {
-    try {
-      this.assertDeepEqual(target, expected, path);
-      throw new Error(`Expected ${path} to NOT be deeply equal, but it is`);
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("Expected")) {
-        return;
-      }
-      throw error;
-    }
-  }
-  assertArraySubset(target, subset, path) {
-    if (subset.length > target.length) {
-      throw new Error(
-        `Expected ${path} to have at least ${subset.length} elements, but got ${target.length}`
-      );
-    }
-    for (let i = 0; i < subset.length; i++) {
-      const currentPath = `${path}[${i}]`;
-      const targetValue = target[i];
-      const subsetValue = subset[i];
-      if (this.isObject(subsetValue) && this.isObject(targetValue)) {
-        this.assertSubset(targetValue, subsetValue, currentPath);
-      } else if (Array.isArray(subsetValue) && Array.isArray(targetValue)) {
-        this.assertArraySubset(targetValue, subsetValue, currentPath);
-      } else if (targetValue !== subsetValue) {
-        throw new Error(
-          `Expected ${currentPath} to be ${subsetValue}, but got ${targetValue}`
-        );
-      }
-    }
-  }
-  assertArrayDeepEqual(target, expected, path) {
-    if (target.length !== expected.length) {
-      throw new Error(
-        `Expected ${path} to have ${expected.length} elements, but got ${target.length}`
-      );
-    }
-    for (let i = 0; i < expected.length; i++) {
-      const currentPath = `${path}[${i}]`;
-      this.assertDeepEqual(target[i], expected[i], currentPath);
-    }
-  }
-  isObject(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-  }
-};
-
-// src/mock/mock_server.ts
-var MockServer = class {
-  server;
-  constructor(server) {
-    this.server = server;
-  }
-  /**
-   * Simulates an HTTP request without making an actual network call, useful for testing purposes
-   * Executes the middleware chain and handler of the route
-   * @param method - The HTTP method (GET, POST, PUT, DELETE, PATCH)
-   * @param path - The request path
-   * @param options - Request options including body, headers, query params, etc.
-   * @throws {Error} - If more than one of body, formData, urlencoded is provided
-   */
-  async request(method, path, options = {}) {
-    const { headers = {}, query = {}, cookies = {}, ip } = options;
-    this.validateOptions(options);
-    const route = router.find(method.toUpperCase(), path);
-    if (!route) {
-      const res = new Response2(404);
-      res.json({
-        caller: "MockServer",
-        error: "Route not found",
-        path,
-        method
-      });
-      return new MockResponse(res);
-    }
-    let body = options.body;
-    let contentType = "application/json";
-    if (body && typeof body === "object" && !(body instanceof Uint8Array) && !(body instanceof ArrayBuffer)) {
-      body = JSON.stringify(body);
-    }
-    if (options.formData) {
-      const boundary = `----WebKitFormBoundary${Math.random().toString(36).substring(2)}`;
-      contentType = `multipart/form-data; boundary=${boundary}`;
-      const multipartBody = await this.formDataToMultipart(
-        options.formData,
-        boundary
-      );
-      body = multipartBody;
-    }
-    if (options.urlencoded) {
-      contentType = "application/x-www-form-urlencoded";
-      body = new URLSearchParams(options.urlencoded).toString();
-    }
-    const url = new URL(
-      `http://${this.server.host}:${this.server.port}${path}`
-    );
-    url.search = new URLSearchParams(query).toString();
-    const req = new Request2(url.toString(), {
-      method: method.toUpperCase(),
-      body: canHaveBody(method) ? body : void 0,
-      headers: {
-        "content-type": contentType,
-        ...headers
-      }
-    });
-    req.query = { ...Object.fromEntries(url.searchParams.entries()), ...query };
-    req.params = route.params;
-    req.cookies = cookies;
-    req.ip = ip;
-    try {
-      const res = await executeMiddlewareChain(
-        route.middleware,
-        route.handler,
-        req
-      );
-      return new MockResponse(res);
-    } catch (error) {
-      logger.error(`Error processing mock request ${method} ${path}:`, error);
-      const errorRes = new Response2(500);
-      errorRes.json({
-        error: "Internal server error",
-        message: error instanceof Error ? error.message : String(error)
-      });
-      return new MockResponse(errorRes);
-    }
-  }
-  async get(path, options) {
-    return this.request("GET", path, options);
-  }
-  async post(path, options) {
-    return this.request("POST", path, options);
-  }
-  async put(path, options) {
-    return this.request("PUT", path, options);
-  }
-  async patch(path, options) {
-    return this.request("PATCH", path, options);
-  }
-  async delete(path, options) {
-    return this.request("DELETE", path, options);
-  }
-  /**
-   * Converts FormData to a proper multipart/form-data body with boundaries
-   */
-  async formDataToMultipart(formData, boundary) {
-    const encoder = new TextEncoder();
-    const buffers = [];
-    for (const [name, value] of formData.entries()) {
-      buffers.push(encoder.encode(`--${boundary}\r
-`));
-      let disposition = `Content-Disposition: form-data; name="${name}"`;
-      let contentType = "";
-      if (value instanceof File) {
-        disposition += `; filename="${value.name}"`;
-        contentType = `Content-Type: ${value.type || "application/octet-stream"}\r
-`;
-      }
-      buffers.push(encoder.encode(`${disposition}\r
-${contentType}\r
-`));
-      if (value instanceof File) {
-        const arrayBuffer = await value.arrayBuffer();
-        buffers.push(new Uint8Array(arrayBuffer));
-        buffers.push(encoder.encode("\r\n"));
-      } else {
-        buffers.push(encoder.encode(`${String(value)}\r
-`));
-      }
-    }
-    buffers.push(encoder.encode(`--${boundary}--\r
-`));
-    const totalLength = buffers.reduce((sum, b) => sum + b.byteLength, 0);
-    const multipartBody = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const buf of buffers) {
-      multipartBody.set(buf, offset);
-      offset += buf.byteLength;
-    }
-    return multipartBody;
-  }
-  validateOptions(options) {
-    const { body, formData, urlencoded: urlencoded2 } = options;
-    if (body && (formData || urlencoded2)) {
-      throw new Error("Only one of body, formData, urlencoded can be provided");
-    }
-    if (formData && (urlencoded2 || body)) {
-      throw new Error("Only one of formData, urlencoded can be provided");
-    }
-    if (urlencoded2 && (body || formData)) {
-      throw new Error("Only one of urlencoded, body can be provided");
-    }
-  }
-};
-
-// src/plugins/urlencoded/urlencoded.ts
-var urlencoded = (options) => {
-  const opts = {
-    limit: 1024 * 1024,
-    extended: false,
-    charset: "utf8",
-    allowEmpty: true,
-    parameterLimit: 1e3,
-    ...options
-  };
-  return async (req, res, next) => {
-    const contentType = req.headers.get("content-type") || "";
-    if (!contentType.includes("application/x-www-form-urlencoded")) {
-      return next();
-    }
-    try {
-      await parseUrlEncodedBody(req, opts);
-      await next();
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("limit")) {
-        res.status(413).json({
-          error: "Payload too large",
-          message: "Request body exceeds the size limit"
-        });
-        return;
-      }
-      throw error;
-    }
-  };
-};
-async function parseUrlEncodedBody(req, opts) {
-  const arrayBuffer = req.rawBody;
-  if (arrayBuffer.byteLength > opts.limit) {
-    throw new Error(
-      `Body size ${arrayBuffer.byteLength} exceeds limit ${opts.limit}`
-    );
-  }
-  const decoder = new TextDecoder(opts.charset);
-  const bodyString = decoder.decode(arrayBuffer);
-  const parsed = parseUrlEncodedString(bodyString, opts);
-  req.body = parsed;
-}
-function parseUrlEncodedString(str, opts) {
-  const result = {};
-  const searchParams = new URLSearchParams(str);
-  if (searchParams.size > opts.parameterLimit) {
-    throw new Error(
-      `Too many parameters: ${searchParams.size} exceeds limit ${opts.parameterLimit}`
-    );
-  }
-  for (const [key, value] of searchParams.entries()) {
-    if (!opts.allowEmpty && value === "") {
-      continue;
-    }
-    if (opts.extended) {
-      setNestedValue(result, key, value);
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-function setNestedValue(obj, key, value) {
-  const keys = key.match(/\[([^\]]*)\]/g);
-  if (!keys) {
-    obj[key] = value;
-    return;
-  }
-  let current = obj;
-  const baseKey = key.split("[")[0];
-  for (let i = 0; i < keys.length - 1; i++) {
-    const bracketKey = keys[i].slice(1, -1);
-    if (!current[baseKey]) {
-      current[baseKey] = {};
-    }
-    if (bracketKey === "") {
-      if (!Array.isArray(current[baseKey])) {
-        current[baseKey] = [];
-      }
-      current = current[baseKey];
-      continue;
-    }
-    if (!current[baseKey][bracketKey]) {
-      current[baseKey][bracketKey] = {};
-    }
-    current = current[baseKey][bracketKey];
-  }
-  const lastKey = keys[keys.length - 1].slice(1, -1);
-  if (lastKey === "") {
-    if (!Array.isArray(current)) {
-      current = [];
-    }
-    current.push(value);
-    return;
-  }
-  current[lastKey] = value;
-}
-
-// src/cron/cron.ts
-import { glob } from "glob";
-var CronService = class {
-  static scheduledJobs = [];
-  /**
-   * @description Schedule a cron job.
-   * @internal
-   * @example
-   * CronService.register('test', '0 0 * * *', () => {
-   *   console.log('test');
-   * }, {
-   *   timezone: 'Europe/Istanbul',
-   * });
-   */
-  static register(name, ...args) {
-    args[2] = {
-      name,
-      ...args[2]
-    };
-    this.scheduledJobs.push({ name, args });
-  }
-  /**
-   * @description Start the cron scheduler.
-   */
-  static async run() {
-    const nodeCronModule = (await import("node-cron").catch(() => {
-      throw new BaldaError(
-        "node-cron not installed as a dependency, it is required in order to run cron jobs with the @cron decorator"
-      );
-    })).default;
-    logger.info("Scheduling cron jobs");
-    if (!this.scheduledJobs.length) {
-      logger.info("No cron jobs to schedule");
-      return;
-    }
-    for (const { name, args } of this.scheduledJobs) {
-      logger.info(`Scheduling cron job: ${name}`);
-      const scheduledJob = nodeCronModule.schedule(...args);
-      scheduledJob.on(
-        "execution:failed",
-        (context) => this.globalErrorHandler(context)
-      );
-    }
-    logger.info("Cron jobs scheduled");
-  }
-  /**
-   * @description Main error handler for cron jobs. You can write your own error handler by overriding this static method for example with sentry.
-   */
-  static globalErrorHandler(context) {
-    logger.error(context.execution?.error);
-  }
-  /**
-   * @description Import all cron jobs from the app/cron/schedules directory
-   */
-  static async massiveImportCronJobs(cronJobPatterns) {
-    const allFiles = [];
-    for (const pattern of cronJobPatterns) {
-      const files = await glob(pattern);
-      allFiles.push(...files);
-    }
-    await Promise.all(
-      allFiles.map(async (file) => {
-        await import(file).catch((error) => {
-          logger.error(`Error importing cron job: ${file}`);
-          logger.error(error);
-        });
-      })
-    );
-  }
-};
-
-// src/server/server.ts
-var Server = class {
-  isListening;
-  wasInitialized;
-  serverConnector;
-  globalMiddlewares = [];
-  options;
-  controllerImportBlacklistedPaths = ["node_modules"];
-  /**
-   * The constructor for the server
-   * @warning Routes will only be defined after calling the `listen` method so you're free to define middlewares before calling it
-   * @param options - The options for the server
-   * @param options.port - The port to listen on, defaults to 80
-   * @param options.host - The hostname to listen on, defaults to 0.0.0.0
-   * @param options.controllerPatterns - The patterns to match for controllers, defaults to an empty array
-   * @param options.plugins - The plugins to apply to the server, by default no plugins are applied, plugins are applied in the order they are defined in the options
-   * @param options.logger - The logger to use for the server, by default a default logger is used
-   * @param options.tapOptions - Options fetch to the runtime server before the server is up and running
-   */
-  constructor(options) {
-    this.wasInitialized = false;
-    this.options = {
-      port: options?.port ?? 80,
-      host: options?.host ?? "0.0.0.0",
-      controllerPatterns: options?.controllerPatterns ?? [],
-      plugins: options?.plugins ?? {},
-      tapOptions: options?.tapOptions ?? {},
-      swagger: options?.swagger ?? true
-    };
-    this.serverConnector = new ServerConnector({
-      routes: [],
-      port: this.options.port,
-      host: this.options.host,
-      tapOptions: this.options.tapOptions,
-      runtime: runtime.type
-    });
-    this.use(bodyParser());
-    this.isListening = false;
-  }
-  get url() {
-    return this.serverConnector.url;
-  }
-  get port() {
-    return this.serverConnector.port;
-  }
-  get host() {
-    return this.serverConnector.host;
-  }
-  tmpDir(...append) {
-    const baseTmpDir = "tmp";
-    if (append) {
-      return join4(baseTmpDir, ...append);
-    }
-    return join4(nativeCwd.getCwd(), baseTmpDir);
-  }
-  get(path, optionsOrHandler, maybeHandler) {
-    const { middlewares, handler, swaggerOptions } = this.extractOptionsAndHandlerFromRouteRegistration(
-      optionsOrHandler,
-      maybeHandler
-    );
-    router.addOrUpdate("GET", path, middlewares, handler, swaggerOptions);
-  }
-  post(path, optionsOrHandler, maybeHandler) {
-    const { middlewares, handler, swaggerOptions } = this.extractOptionsAndHandlerFromRouteRegistration(
-      optionsOrHandler,
-      maybeHandler
-    );
-    router.addOrUpdate("POST", path, middlewares, handler, swaggerOptions);
-  }
-  patch(path, optionsOrHandler, maybeHandler) {
-    const { middlewares, handler, swaggerOptions } = this.extractOptionsAndHandlerFromRouteRegistration(
-      optionsOrHandler,
-      maybeHandler
-    );
-    router.addOrUpdate("PATCH", path, middlewares, handler, swaggerOptions);
-  }
-  put(path, optionsOrHandler, maybeHandler) {
-    const { middlewares, handler, swaggerOptions } = this.extractOptionsAndHandlerFromRouteRegistration(
-      optionsOrHandler,
-      maybeHandler
-    );
-    router.addOrUpdate("PUT", path, middlewares, handler, swaggerOptions);
-  }
-  delete(path, optionsOrHandler, maybeHandler) {
-    const { middlewares, handler, swaggerOptions } = this.extractOptionsAndHandlerFromRouteRegistration(
-      optionsOrHandler,
-      maybeHandler
-    );
-    router.addOrUpdate("DELETE", path, middlewares, handler, swaggerOptions);
-  }
-  getNodeServer() {
-    if (runtime.type !== "node") {
-      throw new Error(
-        "Server is not using node runtime, you can't call `.getNodeServer()`"
-      );
-    }
-    return this.serverConnector.getServer("node");
-  }
-  embed(key, value) {
-    if (typeof key !== "string" || key.trim() === "") {
-      throw new Error(
-        `Invalid key provided to embed: ${key}. Key must be a non-empty string.`
-      );
-    }
-    if (PROTECTED_KEYS.includes(key)) {
-      throw new Error(
-        `Cannot embed value with key '${key}' as it conflicts with a protected server property.`
-      );
-    }
-    Object.defineProperty(this, key, {
-      value,
-      writable: false,
-      configurable: true,
-      enumerable: true
-    });
-  }
-  exit(code = 0) {
-    switch (runtime.type) {
-      case "bun":
-      case "node":
-        process.exit(code);
-      case "deno":
-        Deno.exit(code);
-      default:
-        throw new Error(`Unsupported runtime: ${runtime.type}`);
-    }
-  }
-  on(event, cb) {
-    switch (runtime.type) {
-      case "bun":
-      case "node":
-        process.on(event, cb);
-        break;
-      case "deno":
-        Deno.addSignalListener(event, cb);
-        break;
-      default:
-        throw new Error(
-          `Unsupported runtime: ${runtime.type}, only node, bun and deno are supported`
-        );
-    }
-  }
-  use(...middlewares) {
-    this.globalMiddlewares.push(...middlewares);
-  }
-  setErrorHandler(errorHandler) {
-    this.globalMiddlewares.unshift(async (req, res, next) => {
-      try {
-        await next();
-      } catch (error) {
-        await errorHandler?.(req, res, next, error);
-      }
-    });
-  }
-  setGlobalCronErrorHandler(globalErrorHandler) {
-    CronService.globalErrorHandler = globalErrorHandler;
-  }
-  startRegisteredCrons = async (cronJobPatterns, onStart) => {
-    if (cronJobPatterns?.length) {
-      await CronService.massiveImportCronJobs(cronJobPatterns);
-    }
-    CronService.run().then(() => {
-      onStart?.();
-    });
-  };
-  listen(cb) {
-    if (this.isListening) {
-      throw new Error(
-        "Server is already listening, you can't call `.listen()` multiple times"
-      );
-    }
-    this.bootstrap().then(() => {
-      this.serverConnector.listen();
-      this.isListening = true;
-      if (this.options.swagger) {
-        swagger(this.options.swagger);
-      }
-      cb?.({
-        port: this.port,
-        host: this.host,
-        url: this.url
-      });
-    });
-  }
-  async close() {
-    await this.serverConnector.close();
-    this.isListening = false;
-  }
-  /**
-   * Returns a mock server instance that can be used to test the server without starting it
-   * It will import the controllers and apply the plugins to the mock server
-   */
-  async getMockServer() {
-    await this.bootstrap();
-    return new MockServer(this);
-  }
-  async importControllers() {
-    const controllerPatterns = this.options.controllerPatterns;
-    let controllerPaths = await Promise.all(
-      controllerPatterns.map(async (pattern) => {
-        return glob2(pattern, {
-          cwd: nativeCwd.getCwd()
-        });
-      })
-    ).then((paths) => paths.flat());
-    controllerPaths = controllerPaths.flat();
-    controllerPaths = controllerPaths.filter(
-      (path) => !this.controllerImportBlacklistedPaths.some(
-        (blacklistedPath) => path.includes(blacklistedPath)
-      )
-    );
-    logger.debug(`Found ${controllerPaths.length} controllers to import`);
-    await Promise.all(
-      controllerPaths.map(async (controllerPath) => {
-        logger.debug(`Importing controller ${controllerPath}`);
-        await import(controllerPath).catch((err) => {
-          logger.error(`Error importing controller ${controllerPath}: ${err}`);
-        });
-      })
-    );
-  }
-  extractOptionsAndHandlerFromRouteRegistration(optionsOrHandler, maybeHandler) {
-    if (typeof optionsOrHandler === "function") {
-      return {
-        middlewares: [],
-        handler: optionsOrHandler,
-        swaggerOptions: void 0
-      };
-    }
-    const options = optionsOrHandler;
-    const middlewares = Array.isArray(options.middlewares) ? options.middlewares : options.middlewares ? [options.middlewares] : [];
-    return {
-      middlewares,
-      handler: maybeHandler,
-      swaggerOptions: options.swagger
-    };
-  }
-  applyPlugins(plugins) {
-    Object.entries(plugins).forEach(([pluginName, pluginOptions]) => {
-      switch (pluginName) {
-        case "cors":
-          this.use(cors(pluginOptions));
-          break;
-        case "json":
-          this.use(json(pluginOptions));
-          break;
-        case "static":
-          this.use(serveStatic(pluginOptions));
-          break;
-        case "fileParser":
-          this.use(fileParser(pluginOptions));
-          break;
-        case "helmet":
-          this.use(helmet(pluginOptions));
-          break;
-        case "cookie":
-          this.use(cookie(pluginOptions));
-          break;
-        case "log":
-          this.use(log(pluginOptions));
-          break;
-        case "rateLimiter":
-          const { keyOptions, storageOptions } = pluginOptions;
-          this.use(rateLimiter(keyOptions, storageOptions));
-          break;
-        case "urlencoded":
-          this.use(urlencoded(pluginOptions));
-          break;
-        default:
-          logger.warn(`Unknown plugin ${pluginName}`);
-          break;
-      }
-    });
-  }
-  /**
-   * Initializes the server by importing the controllers and applying the plugins, it's idempotent, it will not re-import the controllers or apply the plugins if the server was already initialized (e.g. mockServer init)
-   * @internal
-   */
-  async bootstrap() {
-    if (this.wasInitialized) {
-      return;
-    }
-    await this.importControllers();
-    this.applyPlugins(this.options.plugins);
-    this.registerNotFoundRoutes();
-    if (this.globalMiddlewares.length) {
-      router.applyGlobalMiddlewaresToAllRoutes(this.globalMiddlewares);
-    }
-    this.wasInitialized = true;
-  }
-  /**
-   * Registers a not found route for all routes that are not defined
-   * @internal
-   */
-  registerNotFoundRoutes() {
-    router.addOrUpdate(
-      "GET",
-      "*",
-      [],
-      (req, res) => {
-        const notFoundError = new RouteNotFoundError(req.url, req.method);
-        res.notFound({
-          ...errorFactory(notFoundError)
-        });
-      },
-      {
-        excludeFromSwagger: true
-      }
-    );
-    router.addOrUpdate(
-      "POST",
-      "*",
-      [],
-      (req, res) => {
-        const notFoundError = new RouteNotFoundError(req.url, req.method);
-        res.notFound({
-          ...errorFactory(notFoundError)
-        });
-      },
-      {
-        excludeFromSwagger: true
-      }
-    );
-    router.addOrUpdate(
-      "PUT",
-      "*",
-      [],
-      (req, res) => {
-        const notFoundError = new RouteNotFoundError(req.url, req.method);
-        res.notFound({
-          ...errorFactory(notFoundError)
-        });
-      },
-      {
-        excludeFromSwagger: true
-      }
-    );
-    router.addOrUpdate(
-      "PATCH",
-      "*",
-      [],
-      (req, res) => {
-        const notFoundError = new RouteNotFoundError(req.url, req.method);
-        res.notFound({
-          ...errorFactory(notFoundError)
-        });
-      },
-      {
-        excludeFromSwagger: true
-      }
-    );
-    router.addOrUpdate(
-      "DELETE",
-      "*",
-      [],
-      (req, res) => {
-        const notFoundError = new RouteNotFoundError(req.url, req.method);
-        res.notFound({
-          ...errorFactory(notFoundError)
-        });
-      },
-      {
-        excludeFromSwagger: true
-      }
-    );
-  }
-};
-
-// src/plugins/base_plugin.ts
-var BasePlugin = class {
-};
-
-// src/index.ts
-var router2 = router;
-export {
-  BasePlugin,
-  Request2 as Request,
-  Response2 as Response,
-  Server,
-  controller,
-  cookie,
-  cors,
-  del,
-  fileParser,
-  get,
-  getContentType,
-  helmet,
-  json,
-  log,
-  middleware,
-  patch,
-  post,
-  put,
-  rateLimiter,
-  router2 as router,
-  serveStatic,
-  urlencoded,
-  validate
-};
-//# sourceMappingURL=index.js.map