@theokit/http 0.4.0

package/dist/index.js

@@ -0,0 +1,761 @@
+import {
+  TheoApp
+} from "./chunk-TBMGRXH5.js";
+import {
+  MiddlewareConsumerImpl,
+  middlewareMatchesPath,
+  runMiddleware
+} from "./chunk-LWCNTZN6.js";
+import {
+  HttpDecoratorsConfigError,
+  createExecutionContext,
+  joinPath,
+  resolveDtoSchema,
+  walkControllerMetadata
+} from "./chunk-SMWUPP2C.js";
+import {
+  createNodeAdapter
+} from "./chunk-HLW7YKZE.js";
+import {
+  runInterceptors
+} from "./chunk-U46H4CGF.js";
+import {
+  runExceptionFilters
+} from "./chunk-34KOKJ5M.js";
+import {
+  BadGatewayException,
+  BadRequestException,
+  CATCH_EXCEPTIONS,
+  CONTROLLER_PREFIX,
+  ConflictException,
+  ForbiddenException,
+  GatewayTimeoutException,
+  GoneException,
+  HttpException,
+  HttpStatus,
+  HttpVersionNotSupportedException,
+  ImATeapotException,
+  InternalServerErrorException,
+  MethodNotAllowedException,
+  NotAcceptableException,
+  NotFoundException,
+  NotImplementedException,
+  PayloadTooLargeException,
+  PreconditionFailedException,
+  ROUTE_HEADERS,
+  ROUTE_METHODS,
+  ROUTE_PARAMS,
+  ROUTE_REDIRECT,
+  ROUTE_STATUS,
+  RequestTimeoutException,
+  ServiceUnavailableException,
+  TooManyRequestsException,
+  USE_FILTERS,
+  USE_GUARDS,
+  USE_INTERCEPTORS,
+  UnauthorizedException,
+  UnprocessableEntityException,
+  UnsupportedMediaTypeException,
+  getMeta,
+  setMeta
+} from "./chunk-3PGQVQWG.js";
+import {
+  resolveOrNew
+} from "./chunk-LKNI6QEP.js";
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/decorators/controller.ts
+function Controller(prefix = "", opts = {}) {
+  return (target) => {
+    setMeta(CONTROLLER_PREFIX, target, {
+      prefix,
+      host: opts.host
+    });
+  };
+}
+__name(Controller, "Controller");
+
+// src/decorators/methods.ts
+function makeVerbDecorator(verb) {
+  return function(path = "") {
+    return (target, propertyKey) => {
+      const existing = getMeta(ROUTE_METHODS, target.constructor) ?? [];
+      existing.push({
+        verb,
+        path,
+        propertyKey
+      });
+      setMeta(ROUTE_METHODS, target.constructor, existing);
+    };
+  };
+}
+__name(makeVerbDecorator, "makeVerbDecorator");
+var Get = makeVerbDecorator("GET");
+var Post = makeVerbDecorator("POST");
+var Put = makeVerbDecorator("PUT");
+var Patch = makeVerbDecorator("PATCH");
+var Delete = makeVerbDecorator("DELETE");
+var Options = makeVerbDecorator("OPTIONS");
+var Head = makeVerbDecorator("HEAD");
+var All = makeVerbDecorator("ALL");
+
+// src/decorators/params.ts
+function isZodSchema(v) {
+  return v !== null && v !== void 0 && typeof v === "object" && typeof v.safeParse === "function";
+}
+__name(isZodSchema, "isZodSchema");
+function makeParamDecorator(source) {
+  return function(keyOrSchema) {
+    return (target, propertyKey, parameterIndex) => {
+      if (propertyKey === void 0) return;
+      const map = getMeta(ROUTE_PARAMS, target.constructor) ?? /* @__PURE__ */ new Map();
+      const entries = map.get(propertyKey) ?? [];
+      const entry = {
+        source,
+        index: parameterIndex
+      };
+      if (typeof keyOrSchema === "string") {
+        entry.key = keyOrSchema;
+      } else if (isZodSchema(keyOrSchema)) {
+        entry.schema = keyOrSchema;
+      }
+      entries.push(entry);
+      map.set(propertyKey, entries);
+      setMeta(ROUTE_PARAMS, target.constructor, map);
+    };
+  };
+}
+__name(makeParamDecorator, "makeParamDecorator");
+var Req = makeParamDecorator("req");
+var Body = makeParamDecorator("body");
+var Param = makeParamDecorator("param");
+var Query = makeParamDecorator("query");
+var Headers = makeParamDecorator("headers");
+var Session = makeParamDecorator("session");
+var Ip = makeParamDecorator("ip");
+var HostParam = makeParamDecorator("host");
+function Res(opts) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey === void 0) return;
+    const map = getMeta(ROUTE_PARAMS, target.constructor) ?? /* @__PURE__ */ new Map();
+    const entries = map.get(propertyKey) ?? [];
+    entries.push({
+      source: "res",
+      index: parameterIndex,
+      passthrough: opts?.passthrough
+    });
+    map.set(propertyKey, entries);
+    setMeta(ROUTE_PARAMS, target.constructor, map);
+  };
+}
+__name(Res, "Res");
+
+// src/decorators/response.ts
+function HttpCode(status) {
+  return (target, propertyKey) => {
+    setMeta(ROUTE_STATUS, target.constructor, status, propertyKey);
+  };
+}
+__name(HttpCode, "HttpCode");
+function Header(name, value) {
+  return (target, propertyKey) => {
+    const existing = getMeta(ROUTE_HEADERS, target.constructor, propertyKey) ?? [];
+    existing.push([
+      name,
+      value
+    ]);
+    setMeta(ROUTE_HEADERS, target.constructor, existing, propertyKey);
+  };
+}
+__name(Header, "Header");
+function Redirect(url, status = 302) {
+  return (target, propertyKey) => {
+    setMeta(ROUTE_REDIRECT, target.constructor, {
+      url,
+      status
+    }, propertyKey);
+  };
+}
+__name(Redirect, "Redirect");
+
+// src/decorators/middleware.ts
+function UseGuards(...guards) {
+  return (target, propertyKey) => {
+    const actualTarget = propertyKey ? target.constructor : target;
+    const existing = getMeta(USE_GUARDS, actualTarget, propertyKey) ?? [];
+    setMeta(USE_GUARDS, actualTarget, [
+      ...existing,
+      ...guards
+    ], propertyKey);
+  };
+}
+__name(UseGuards, "UseGuards");
+function UseInterceptors(...interceptors) {
+  return (target, propertyKey) => {
+    const actualTarget = propertyKey ? target.constructor : target;
+    const existing = getMeta(USE_INTERCEPTORS, actualTarget, propertyKey) ?? [];
+    setMeta(USE_INTERCEPTORS, actualTarget, [
+      ...existing,
+      ...interceptors
+    ], propertyKey);
+  };
+}
+__name(UseInterceptors, "UseInterceptors");
+function UseFilters(...filters) {
+  return (target, propertyKey) => {
+    const actualTarget = propertyKey ? target.constructor : target;
+    const existing = getMeta(USE_FILTERS, actualTarget, propertyKey) ?? [];
+    setMeta(USE_FILTERS, actualTarget, [
+      ...existing,
+      ...filters
+    ], propertyKey);
+  };
+}
+__name(UseFilters, "UseFilters");
+function Catch(...exceptions) {
+  return (target) => {
+    setMeta(CATCH_EXCEPTIONS, target, exceptions);
+  };
+}
+__name(Catch, "Catch");
+
+// src/decorators/set-metadata.ts
+import "reflect-metadata";
+var decoratorKeyCounter = 0;
+function createDecorator() {
+  const key = /* @__PURE__ */ Symbol.for(`theokit:custom:${++decoratorKeyCounter}`);
+  const decorator = /* @__PURE__ */ __name((value) => {
+    return (target, propertyKey) => {
+      const metaTarget = propertyKey !== void 0 ? target.constructor : target;
+      Reflect.defineMetadata(key, value, metaTarget, propertyKey);
+    };
+  }, "decorator");
+  decorator.key = key;
+  return decorator;
+}
+__name(createDecorator, "createDecorator");
+function SetMetadata(metaKey, value) {
+  return (target, propertyKey) => {
+    const metaTarget = propertyKey !== void 0 ? target.constructor : target;
+    Reflect.defineMetadata(metaKey, value, metaTarget, propertyKey);
+  };
+}
+__name(SetMetadata, "SetMetadata");
+var Reflector = class {
+  static {
+    __name(this, "Reflector");
+  }
+  /**
+  * Read metadata set by a typed decorator created via createDecorator<T>().
+  *
+  * @example
+  * ```ts
+  * const Roles = createDecorator<string[]>()
+  * const reflector = new Reflector()
+  * const roles = reflector.get(Roles, handlerFn) // string[] | undefined
+  * ```
+  */
+  get(decorator, target, propertyKey) {
+    const key = decorator.key;
+    if (!key) return void 0;
+    if (propertyKey !== void 0) {
+      return Reflect.getMetadata(key, target, propertyKey);
+    }
+    return Reflect.getMetadata(key, target);
+  }
+  /**
+  * Read metadata set by @SetMetadata(key, value).
+  */
+  getByKey(key, target, propertyKey) {
+    if (propertyKey !== void 0) {
+      return Reflect.getMetadata(key, target, propertyKey);
+    }
+    return Reflect.getMetadata(key, target);
+  }
+  /**
+  * Read metadata checking method-level first, then class-level.
+  * Returns the first non-undefined value found.
+  *
+  * NestJS equivalent: `reflector.getAllAndOverride(ROLES_KEY, [context.getHandler(), context.getClass()])`
+  *
+  * @example
+  * ```ts
+  * const Roles = createDecorator<string[]>()
+  * // In a guard:
+  * const roles = reflector.getAllAndOverride(Roles, context.getClass(), context.getMethodName())
+  * // Checks method-level @Roles first, falls back to class-level @Roles
+  * ```
+  */
+  getAllAndOverride(decorator, target, propertyKey) {
+    if (propertyKey !== void 0) {
+      const methodLevel = this.get(decorator, target, propertyKey);
+      if (methodLevel !== void 0) return methodLevel;
+    }
+    return this.get(decorator, target);
+  }
+  /**
+  * Read metadata checking method-level first, then class-level, by raw key.
+  * Returns the first non-undefined value found.
+  */
+  getAllAndOverrideByKey(key, target, propertyKey) {
+    if (propertyKey !== void 0) {
+      const methodLevel = this.getByKey(key, target, propertyKey);
+      if (methodLevel !== void 0) return methodLevel;
+    }
+    return this.getByKey(key, target);
+  }
+  /**
+  * Read metadata from both method-level and class-level, merging arrays.
+  * Returns all found values as a flat array.
+  *
+  * NestJS equivalent: `reflector.getAllAndMerge(ROLES_KEY, [context.getHandler(), context.getClass()])`
+  *
+  * @example
+  * ```ts
+  * const Tags = createDecorator<string[]>()
+  *
+  * @Tags(['api'])
+  * @Controller('cats')
+  * class CatsCtrl {
+  *   @Tags(['read'])
+  *   @Get()
+  *   findAll() {}
+  * }
+  *
+  * reflector.getAllAndMerge(Tags, CatsCtrl, 'findAll')
+  * // → ['read', 'api'] (method + class merged)
+  * ```
+  */
+  getAllAndMerge(decorator, target, propertyKey) {
+    const result = [];
+    if (propertyKey !== void 0) {
+      const methodLevel = this.get(decorator, target, propertyKey);
+      if (methodLevel !== void 0) {
+        if (Array.isArray(methodLevel)) result.push(...methodLevel);
+        else result.push(methodLevel);
+      }
+    }
+    const classLevel = this.get(decorator, target);
+    if (classLevel !== void 0) {
+      if (Array.isArray(classLevel)) result.push(...classLevel);
+      else result.push(classLevel);
+    }
+    return result;
+  }
+};
+
+// src/decorators/throttle.ts
+var THROTTLE_KEY = /* @__PURE__ */ Symbol.for("theokit:http-decorators:throttle");
+var SKIP_THROTTLE_KEY = /* @__PURE__ */ Symbol.for("theokit:http-decorators:skip-throttle");
+function Throttle(options) {
+  return (target, propertyKey) => {
+    const actualTarget = propertyKey !== void 0 ? target.constructor : target;
+    setMeta(THROTTLE_KEY, actualTarget, options, propertyKey);
+  };
+}
+__name(Throttle, "Throttle");
+function SkipThrottle(skip = true) {
+  return (target, propertyKey) => {
+    const actualTarget = propertyKey !== void 0 ? target.constructor : target;
+    setMeta(SKIP_THROTTLE_KEY, actualTarget, skip, propertyKey);
+  };
+}
+__name(SkipThrottle, "SkipThrottle");
+function getThrottleOptions(target, propertyKey) {
+  return getMeta(THROTTLE_KEY, target, propertyKey);
+}
+__name(getThrottleOptions, "getThrottleOptions");
+function isThrottleSkipped(target, propertyKey) {
+  return getMeta(SKIP_THROTTLE_KEY, target, propertyKey) ?? false;
+}
+__name(isThrottleSkipped, "isThrottleSkipped");
+
+// src/bridge/register-controllers.ts
+function registerControllers(controllers) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const Ctor of controllers) {
+    if (seen.has(Ctor)) {
+      console.warn(`[@theokit/http] Controller ${Ctor.name} registered multiple times \u2014 dropping duplicate`);
+      continue;
+    }
+    seen.add(Ctor);
+    unique.push(Ctor);
+  }
+  return unique.flatMap((Ctor) => {
+    const walks = walkControllerMetadata(Ctor);
+    return walks.map((w) => ({
+      verb: w.verb,
+      fullPath: w.fullPath,
+      walkResult: w
+    }));
+  });
+}
+__name(registerControllers, "registerControllers");
+
+// src/bridge/create-server.ts
+import "reflect-metadata";
+function createDecoratorServer(controllersOrOpts) {
+  const { controllers, container, configure } = Array.isArray(controllersOrOpts) ? {
+    controllers: controllersOrOpts,
+    container: void 0,
+    configure: void 0
+  } : controllersOrOpts;
+  const middlewareConsumer = new MiddlewareConsumerImpl(container);
+  if (configure) configure(middlewareConsumer);
+  const middlewareEntries = middlewareConsumer.getEntries();
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const Ctor of controllers) {
+    if (seen.has(Ctor)) continue;
+    seen.add(Ctor);
+    unique.push(Ctor);
+  }
+  const routes = [];
+  for (const Ctor of unique) {
+    const instance = resolveOrNew(Ctor, container);
+    const walks = walkControllerMetadata(Ctor);
+    for (const w of walks) {
+      routes.push({
+        walk: w,
+        instance
+      });
+    }
+  }
+  routes.sort((a, b) => {
+    const aP = a.walk.fullPath.includes(":");
+    const bP = b.walk.fullPath.includes(":");
+    if (aP !== bP) return aP ? 1 : -1;
+    return 0;
+  });
+  const adapter = createNodeAdapter();
+  const handler = /* @__PURE__ */ __name((request) => handleRequest(routes, request, container, middlewareEntries), "handler");
+  return adapter.createServer(handler);
+}
+__name(createDecoratorServer, "createDecoratorServer");
+async function handleRequest(routes, request, container, middlewareEntries = []) {
+  const url = new URL(request.url);
+  const method = request.method.toUpperCase();
+  const pathname = url.pathname;
+  const match = findRoute(routes, method, pathname);
+  if (!match) {
+    return jsonResponse(404, {
+      error: {
+        code: "NOT_FOUND",
+        message: `No route for ${method} ${pathname}`
+      }
+    });
+  }
+  const { walk, instance, params } = match;
+  try {
+    const mwResponse = await runMiddleware(middlewareEntries, request, pathname);
+    if (mwResponse) return mwResponse;
+    const ctx = createExecutionContext(request, instance.constructor, walk.propertyKey);
+    const guardResponse = await runGuards(walk.guards, ctx, container);
+    if (guardResponse) return guardResponse;
+    const body = await resolveBody(method, request, walk);
+    if (body instanceof Response) return body;
+    const args = buildArgs(walk.paramEntries, {
+      request,
+      body,
+      params,
+      query: Object.fromEntries(url.searchParams)
+    });
+    if (walk.redirect) {
+      return new Response(null, {
+        status: walk.redirect.status,
+        headers: {
+          location: walk.redirect.url
+        }
+      });
+    }
+    const handlerFn = instance[walk.propertyKey];
+    const result = await runInterceptors(walk.interceptors, () => handlerFn.apply(instance, args), request, container);
+    return buildResponse(result, walk, method);
+  } catch (err) {
+    return runExceptionFilters(err, walk.filters, request, container);
+  }
+}
+__name(handleRequest, "handleRequest");
+async function runGuards(guards, context, container) {
+  for (const GuardCtor of guards) {
+    const guard = resolveOrNew(GuardCtor, container);
+    const allowed = await guard.canActivate(context);
+    if (!allowed) {
+      const ex = new ForbiddenException("Forbidden resource");
+      return jsonResponse(ex.statusCode, ex.toJSON());
+    }
+  }
+  return null;
+}
+__name(runGuards, "runGuards");
+async function resolveBody(method, request, walk) {
+  if (![
+    "POST",
+    "PUT",
+    "PATCH"
+  ].includes(method)) return void 0;
+  let body;
+  try {
+    const text = await request.text();
+    body = text ? JSON.parse(text) : void 0;
+  } catch {
+    body = void 0;
+  }
+  if (walk.bodySchema && body !== void 0) {
+    const result = walk.bodySchema.safeParse(body);
+    if (!result.success) {
+      return jsonResponse(422, {
+        error: {
+          code: "VALIDATION_ERROR",
+          issues: result.error.issues
+        }
+      });
+    }
+    body = result.data;
+  }
+  return body;
+}
+__name(resolveBody, "resolveBody");
+function buildResponse(result, walk, method) {
+  const status = walk.status ?? (method === "POST" ? 201 : 200);
+  const headers = {
+    "content-type": "application/json"
+  };
+  for (const [name, value] of walk.headers) {
+    headers[name.toLowerCase()] = value;
+  }
+  if (result === void 0 || result === null) {
+    return new Response(null, {
+      status: status === 200 ? 204 : status,
+      headers
+    });
+  }
+  if (typeof result === "string") {
+    headers["content-type"] = "text/plain";
+    return new Response(result, {
+      status,
+      headers
+    });
+  }
+  return new Response(JSON.stringify(result), {
+    status,
+    headers
+  });
+}
+__name(buildResponse, "buildResponse");
+function jsonResponse(status, body) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: {
+      "content-type": "application/json"
+    }
+  });
+}
+__name(jsonResponse, "jsonResponse");
+function findRoute(routes, method, pathname) {
+  for (const { walk, instance } of routes) {
+    if (walk.verb !== "ALL" && walk.verb !== method) continue;
+    const params = matchPath(walk.fullPath, pathname);
+    if (params !== null) return {
+      walk,
+      instance,
+      params
+    };
+  }
+  return null;
+}
+__name(findRoute, "findRoute");
+function matchPath(pattern, pathname) {
+  const paramNames = [];
+  const regexStr = pattern.replace(/:(\w+)/g, (_m, name) => {
+    paramNames.push(name);
+    return "([^/]+)";
+  });
+  const match = new RegExp(`^${regexStr}$`).exec(pathname);
+  if (!match) return null;
+  const params = {};
+  paramNames.forEach((name, i) => {
+    params[name] = match[i + 1];
+  });
+  return params;
+}
+__name(matchPath, "matchPath");
+function buildArgs(paramEntries, ctx) {
+  if (paramEntries.length === 0) return [];
+  const maxIndex = Math.max(...paramEntries.map((p) => p.index));
+  const args = Array.from({
+    length: maxIndex + 1
+  }, () => void 0);
+  for (const p of paramEntries) {
+    switch (p.source) {
+      case "req":
+        args[p.index] = ctx.request;
+        break;
+      case "body":
+        args[p.index] = p.key ? ctx.body[p.key] : ctx.body;
+        break;
+      case "param":
+        args[p.index] = p.key ? ctx.params[p.key] : ctx.params;
+        break;
+      case "query":
+        args[p.index] = p.key ? ctx.query[p.key] : ctx.query;
+        break;
+      case "headers":
+        args[p.index] = p.key ? ctx.request.headers.get(p.key.toLowerCase()) : Object.fromEntries(ctx.request.headers.entries());
+        break;
+      case "ip":
+        args[p.index] = ctx.request.headers.get("x-forwarded-for") ?? "127.0.0.1";
+        break;
+      case "session":
+        args[p.index] = void 0;
+        break;
+      default:
+        args[p.index] = void 0;
+    }
+  }
+  return args;
+}
+__name(buildArgs, "buildArgs");
+
+// src/typed-client.ts
+function createTypedClient(baseUrl, defaultHeaders) {
+  async function request(method, path, body, opts) {
+    const url = new URL(path, baseUrl);
+    if (opts?.query) {
+      for (const [k, v] of Object.entries(opts.query)) url.searchParams.set(k, v);
+    }
+    const headers = {
+      ...defaultHeaders,
+      ...opts?.headers
+    };
+    if (body !== void 0) headers["content-type"] = "application/json";
+    const res = await fetch(url.toString(), {
+      method,
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const error = await res.json().catch(() => ({
+        message: res.statusText
+      }));
+      throw new TypedClientError(res.status, error);
+    }
+    if (res.status === 204) return void 0;
+    return res.json();
+  }
+  __name(request, "request");
+  return {
+    get: /* @__PURE__ */ __name((path, opts) => request("GET", path, void 0, opts), "get"),
+    post: /* @__PURE__ */ __name((path, body, opts) => request("POST", path, body, opts), "post"),
+    put: /* @__PURE__ */ __name((path, body, opts) => request("PUT", path, body, opts), "put"),
+    delete: /* @__PURE__ */ __name((path, opts) => request("DELETE", path, void 0, opts), "delete")
+  };
+}
+__name(createTypedClient, "createTypedClient");
+var TypedClientError = class extends Error {
+  static {
+    __name(this, "TypedClientError");
+  }
+  status;
+  body;
+  constructor(status, body) {
+    super(`HTTP ${status}: ${JSON.stringify(body)}`), this.status = status, this.body = body;
+    this.name = "TypedClientError";
+  }
+};
+
+// src/contract.ts
+function contract(routes) {
+  return routes;
+}
+__name(contract, "contract");
+export {
+  All,
+  BadGatewayException,
+  BadRequestException,
+  Body,
+  CATCH_EXCEPTIONS,
+  CONTROLLER_PREFIX,
+  Catch,
+  ConflictException,
+  Controller,
+  Delete,
+  ForbiddenException,
+  GatewayTimeoutException,
+  Get,
+  GoneException,
+  Head,
+  Header,
+  Headers,
+  HostParam,
+  HttpCode,
+  HttpDecoratorsConfigError,
+  HttpException,
+  HttpStatus,
+  HttpVersionNotSupportedException,
+  ImATeapotException,
+  InternalServerErrorException,
+  Ip,
+  MethodNotAllowedException,
+  MiddlewareConsumerImpl,
+  NotAcceptableException,
+  NotFoundException,
+  NotImplementedException,
+  Options,
+  Param,
+  Patch,
+  PayloadTooLargeException,
+  Post,
+  PreconditionFailedException,
+  Put,
+  Query,
+  ROUTE_HEADERS,
+  ROUTE_METHODS,
+  ROUTE_PARAMS,
+  ROUTE_REDIRECT,
+  ROUTE_STATUS,
+  Redirect,
+  Reflector,
+  Req,
+  RequestTimeoutException,
+  Res,
+  ServiceUnavailableException,
+  Session,
+  SetMetadata,
+  SkipThrottle,
+  TheoApp,
+  Throttle,
+  TooManyRequestsException,
+  TypedClientError,
+  USE_FILTERS,
+  USE_GUARDS,
+  USE_INTERCEPTORS,
+  UnauthorizedException,
+  UnprocessableEntityException,
+  UnsupportedMediaTypeException,
+  UseFilters,
+  UseGuards,
+  UseInterceptors,
+  contract,
+  createDecorator,
+  createDecoratorServer,
+  createExecutionContext,
+  createTypedClient,
+  getMeta,
+  getThrottleOptions,
+  isThrottleSkipped,
+  joinPath,
+  middlewareMatchesPath,
+  registerControllers,
+  resolveDtoSchema,
+  resolveOrNew,
+  runExceptionFilters,
+  runInterceptors,
+  runMiddleware,
+  setMeta,
+  walkControllerMetadata
+};
+//# sourceMappingURL=index.js.map