equipped 5.2.9 → 5.3.0-alpha.0

package/dist/types/kafka-Cf-TUJgv.d.ts

@@ -1,54 +0,0 @@
-import { E as Events } from './overrides-6Hxg764S.js';
-import * as valleyed from 'valleyed';
-import { PipeOutput } from 'valleyed';
-
-type StreamOptions = {
-    skipScope?: boolean;
-    fanout: boolean;
-};
-declare abstract class EventBus {
-    abstract createStream<Event extends Events[keyof Events]>(topic: Event['topic'], options?: Partial<StreamOptions>): {
-        publish: (data: Event['data']) => Promise<boolean>;
-        subscribe: (onMessage: (data: Event['data']) => Promise<void>) => void;
-    };
-}
-
-declare const rabbitmqConfigPipe: () => valleyed.Pipe<{
-    uri: string;
-    eventColumnName: string;
-}, {
-    uri: string;
-    eventColumnName: string;
-}>;
-declare const kafkaConfigPipe: () => valleyed.Pipe<{
-    brokers: string[];
-    ssl: boolean | undefined;
-    sasl: {
-        mechanism: "plain";
-        username: string;
-        password: string;
-    } | undefined;
-    clientId: string | undefined;
-}, {
-    brokers: string[];
-    ssl: boolean | undefined;
-    sasl: {
-        mechanism: "plain";
-        username: string;
-        password: string;
-    } | undefined;
-    clientId: string | undefined;
-}>;
-type KafkaConfig = PipeOutput<ReturnType<typeof kafkaConfigPipe>>;
-type RabbitMQConfig = PipeOutput<ReturnType<typeof rabbitmqConfigPipe>>;
-
-declare class KafkaEventBus extends EventBus {
-    #private;
-    constructor(config: KafkaConfig);
-    createStream<Event extends Events[keyof Events]>(topicName: Event['topic'], options?: Partial<StreamOptions>): {
-        publish: (data: Event["data"]) => Promise<boolean>;
-        subscribe: (onMessage: (data: Event["data"]) => Promise<void>) => void;
-    };
-}
-
-export { EventBus as E, KafkaEventBus as K, type RabbitMQConfig as R, type StreamOptions as S, type KafkaConfig as a, kafkaConfigPipe as k, rabbitmqConfigPipe as r };

package/dist/types/server/impls/base.js

@@ -1,210 +0,0 @@
-import {} from "@fastify/cors";
-import {} from "cors";
-import { Server as SocketServer } from "socket.io";
-import supertest from "supertest";
-import { PipeError, v } from "valleyed";
-import { EquippedError, NotFoundError, RequestError } from "../../errors/index.js";
-import { Instance } from "../../instance/index.js";
-import { pipeErrorToValidationError } from "../../validations/index.js";
-import { requestLocalStorage, responseLocalStorage } from "../../validations/valleyed.js";
-import { OpenApi } from "../openapi.js";
-import { Response } from "../requests.js";
-import { Router } from "../routes.js";
-import { SocketEmitter } from "../sockets.js";
-import { Methods, StatusCodes } from "../types.js";
-const errorsSchemas = Object.entries(StatusCodes).filter(([, value]) => value > 399).map(([key, value]) => ({
-  status: value,
-  contentType: "application/json",
-  pipe: v.meta(v.array(v.object({ message: v.string(), field: v.optional(v.string()) })), {
-    $refId: `Errors.${key}Response`,
-    description: `${key} Response`
-  })
-}));
-class Server {
-  constructor(server, config, implementations) {
-    this.config = config;
-    this.implementations = implementations;
-    this.server = server;
-    this.#openapi = new OpenApi(config);
-    const socketInstance = new SocketServer(server, { cors: this.cors });
-    this.socket = new SocketEmitter(socketInstance, config);
-    this.addRouter(this.#openapi.router());
-  }
-  #queue = [];
-  #routesByKey = /* @__PURE__ */ new Map();
-  #openapi;
-  socket;
-  server;
-  get cors() {
-    return {
-      origin: this.config.cors?.origin ? (_, cb) => cb(null, true) : this.config.cors?.origin,
-      methods: (this.config.cors?.methods ?? Object.values(Methods)).filter((m) => m !== Methods.options).map((m) => m.toUpperCase()),
-      credentials: this.config.cors?.credentials
-    };
-  }
-  addRouter(...routers) {
-    routers.map((router) => router.routes).forEach((routes) => this.addRoute(...routes));
-  }
-  addRoute(...routes) {
-    routes.forEach((route) => {
-      this.#queue.push(async () => {
-        const { method, path, schema = {}, onError, middlewares = [], responseMiddlewares = [] } = route;
-        const key = `(${method.toUpperCase()}) ${this.#openapi.cleanPath(path)}`;
-        if (this.#routesByKey.get(key))
-          throw new EquippedError(`Route key ${key} already registered. All route keys must be unique`, { route, key });
-        middlewares.forEach((m) => m.onSetup?.(route));
-        onError?.onSetup?.(route);
-        responseMiddlewares.forEach((m) => m.onSetup?.(route));
-        const { validateRequest, validateResponse, jsonSchema } = this.#resolveSchema(method, schema);
-        this.#routesByKey.set(key, true);
-        await this.#openapi.register(route, jsonSchema);
-        this.implementations.registerRoute(method, this.#openapi.cleanPath(path), async (req, res) => {
-          const request = await validateRequest(await this.implementations.parseRequest(req));
-          try {
-            for (const middleware of middlewares) await middleware.cb(request);
-            const rawRes = await route.handler(request);
-            const response = rawRes instanceof Response ? rawRes : new Response({ body: rawRes, status: StatusCodes.Ok, headers: {}, piped: false });
-            for (const middleware of responseMiddlewares) await middleware.cb(request, response);
-            return await this.implementations.handleResponse(res, await validateResponse(response));
-          } catch (error) {
-            if (onError?.cb) {
-              const rawResponse = await onError.cb(request, error);
-              const response = rawResponse instanceof Response ? rawResponse : new Response({ body: rawResponse, status: StatusCodes.BadRequest, headers: {} });
-              return await this.implementations.handleResponse(res, await validateResponse(response));
-            }
-            throw error;
-          }
-        });
-      });
-    });
-  }
-  #resolveSchema(method, schema) {
-    const defaultStatusCode = schema?.defaultStatusCode ?? StatusCodes.Ok;
-    const defaultContentType = schema?.defaultContentType ?? "application/json";
-    let status = defaultStatusCode;
-    let contentType = defaultContentType;
-    const jsonSchema = { response: {}, request: {} };
-    const requestPipeDefs = {};
-    const responsePipeDefs = {};
-    const defs = [
-      { key: "params", type: "request" },
-      { key: "headers", type: "request" },
-      { key: "cookies", type: "request" },
-      { key: "query", type: "request" },
-      { key: "body", type: "request", skip: ![Methods.post, Methods.put, Methods.patch].includes(method) },
-      { key: "response", type: "response" },
-      { key: "responseHeaders", type: "response" },
-      { key: "responseCookies", type: "response" }
-    ];
-    defs.forEach((def) => {
-      const pipe = schema[def.key] ?? v.any();
-      if (def.skip) return;
-      if (def.type === "request") {
-        requestPipeDefs[def.key] = pipe;
-        jsonSchema.request[def.key] = v.schema(pipe);
-      }
-      if (def.type === "response") {
-        const pipeRecords = errorsSchemas.concat({ status: defaultStatusCode, contentType, pipe });
-        responsePipeDefs[def.key] = v.any().pipe((input) => {
-          const p = pipeRecords.find((r) => r.status === status)?.pipe;
-          if (!p) throw PipeError.root(`schema not defined for status code: ${status}`, input);
-          return v.assert(p, input);
-        });
-        jsonSchema.response[def.key] = pipeRecords.map((record) => ({
-          status: record.status,
-          contentType: record.contentType,
-          schema: v.schema(record.pipe)
-        }));
-      }
-    });
-    const requestPipe = v.object(requestPipeDefs);
-    v.compile(requestPipe, { allErrors: true });
-    const responsePipe = v.object(responsePipeDefs);
-    v.compile(responsePipe, { allErrors: true });
-    const validateRequest = async (request) => {
-      if (!Object.keys(requestPipeDefs)) return request;
-      const validity = requestLocalStorage.run(
-        request,
-        () => v.validate(requestPipe, {
-          params: request.params,
-          headers: request.headers,
-          query: request.query,
-          body: request.body,
-          cookies: request.cookies
-        })
-      );
-      if (!validity.valid) throw pipeErrorToValidationError(validity.error);
-      request.params = validity.value.params;
-      request.headers = validity.value.headers;
-      request.query = validity.value.query;
-      request.body = validity.value.body;
-      request.cookies = validity.value.cookies;
-      return request;
-    };
-    const validateResponse = async (response) => {
-      if (!Object.keys(responsePipeDefs)) return response;
-      status = response.status;
-      contentType = response.contentType;
-      const validity = responseLocalStorage.run(
-        response,
-        () => v.validate(responsePipe, {
-          responseHeaders: response.headers,
-          responseCookies: Object.fromEntries(Object.entries(response.cookies).map(([key, val]) => [key, val.value])),
-          response: response.body
-        })
-      );
-      if (!validity.valid) throw pipeErrorToValidationError(validity.error);
-      response.body = validity.value.response;
-      response.headers = validity.value.responseHeaders;
-      response.cookieValues = validity.value.responseCookies;
-      return response;
-    };
-    return {
-      jsonSchema,
-      validateRequest,
-      validateResponse
-    };
-  }
-  test() {
-    return supertest(this.server);
-  }
-  async start() {
-    const port = this.config.port;
-    const instance = Instance.get();
-    const { app } = instance.settings;
-    if (this.config.healthPath)
-      this.addRoute({
-        method: Methods.get,
-        path: this.config.healthPath,
-        handler: async (req) => req.res({
-          body: `${instance.id}(${app.name}) service running`,
-          contentType: "text/plain"
-        })
-      });
-    await Promise.all(this.#queue.map((cb) => cb()));
-    this.implementations.registerNotFoundHandler(async (req) => {
-      const request = await this.implementations.parseRequest(req);
-      throw new NotFoundError(`Route ${request.path} not found`);
-    });
-    this.implementations.registerErrorHandler(async (error, _, res) => {
-      if (!(error instanceof EquippedError)) Instance.get().log.error({ error }, "Uncaught error in route handler");
-      const response = error instanceof RequestError ? new Response({
-        body: error.serializedErrors,
-        status: error.statusCode
-      }) : error instanceof EquippedError ? new Response({
-        body: [{ message: error.message }],
-        status: StatusCodes.BadRequest
-      }) : new Response({
-        body: [{ message: "Something went wrong", data: error.message }],
-        status: StatusCodes.BadRequest
-      });
-      return await this.implementations.handleResponse(res, response);
-    });
-    const started = await this.implementations.start(port);
-    if (started) Instance.get().log.info(`${instance.id}(${app.name}) service listening on port ${port}`);
-    return started;
-  }
-}
-export {
-  Server
-};

package/dist/types/server/impls/express.js

@@ -1,110 +0,0 @@
-import http from "http";
-import cookie from "cookie-parser";
-import cors from "cors";
-import express from "express";
-import fileUpload from "express-fileupload";
-import { rateLimit } from "express-rate-limit";
-import helmet from "helmet";
-import { pinoHttp } from "pino-http";
-import { Instance } from "../../instance/index.js";
-import { getMediaDuration } from "../../utilities/index.js";
-import { Request } from "../requests.js";
-import { StatusCodes } from "../types.js";
-import { Server } from "./base.js";
-class ExpressServer extends Server {
-  constructor(config) {
-    const app = express();
-    const instance = Instance.get();
-    super(http.createServer(app), config, {
-      parseRequest: async (req) => {
-        const files = Object.fromEntries(
-          await Promise.all(
-            Object.entries(req.files ?? {}).map(async ([key, file]) => {
-              const uploads = Array.isArray(file) ? file : [file];
-              const fileArray = await Promise.all(
-                uploads.map(async (f) => ({
-                  name: f.name,
-                  type: f.mimetype,
-                  size: f.size,
-                  isTruncated: f.truncated,
-                  data: f.data,
-                  duration: await getMediaDuration(f.data)
-                }))
-              );
-              return [key, fileArray];
-            })
-          )
-        );
-        return new Request({
-          ip: req.ip,
-          body: req.body ?? {},
-          cookies: req.cookies ?? {},
-          params: req.params ?? {},
-          query: req.query ?? {},
-          method: req.method,
-          path: req.path,
-          headers: req.headers,
-          files
-        });
-      },
-      handleResponse: async (res, response) => {
-        if (!response.piped) {
-          Object.entries(response.headers).forEach(([key, value]) => res.header(key, value));
-          Object.entries(response.cookies).forEach(([key, { value, ...opts }]) => res.cookie(key, value, opts));
-          const type = response.body === null || response.body === void 0 ? "json" : "send";
-          res.status(response.status)[type](response.body).end();
-        } else {
-          response.body.pipe(res);
-        }
-      },
-      registerRoute: (method, path, cb) => {
-        app[method]?.(path, async (req, res) => cb(req, res));
-      },
-      registerErrorHandler: (cb) => {
-        app.use(async (err, req, res, _next) => cb(err, req, res));
-      },
-      registerNotFoundHandler: (cb) => {
-        app.use(async (req, res, _next) => cb(req, res));
-      },
-      start: async (port) => new Promise((resolve, reject) => {
-        try {
-          const app2 = this.server.listen({ host: "0.0.0.0", port }, async () => resolve(true));
-          Instance.on("close", app2.close, 1);
-        } catch (err) {
-          reject(err);
-        }
-      })
-    });
-    app.disable("x-powered-by");
-    if (config.requests.log) app.use(pinoHttp({ logger: instance.log }));
-    app.use(express.json());
-    app.use(express.text());
-    app.use(cookie());
-    app.use(
-      helmet({
-        crossOriginResourcePolicy: { policy: "cross-origin" },
-        contentSecurityPolicy: false
-      })
-    );
-    app.use(cors(this.cors));
-    app.use(express.urlencoded({ extended: false }));
-    if (config.publicPath) app.use(express.static(config.publicPath));
-    app.use(
-      fileUpload({
-        limits: { fileSize: instance.settings.utils.maxFileUploadSizeInMb * 1024 * 1024 },
-        useTempFiles: false
-      })
-    );
-    if (config.requests.rateLimit.enabled)
-      app.use(
-        rateLimit({
-          windowMs: config.requests.rateLimit.periodInMs,
-          limit: config.requests.rateLimit.limit,
-          handler: (_, res) => res.status(StatusCodes.TooManyRequests).json([{ message: "Too Many Requests" }])
-        })
-      );
-  }
-}
-export {
-  ExpressServer
-};

package/dist/types/server/middlewares/index.js

@@ -1 +0,0 @@
-export * from "./requireAuthUser.js";

package/dist/types/server/middlewares/requireAuthUser.js

@@ -1,21 +0,0 @@
-import { NotAuthenticatedError } from "../../errors/index.js";
-import { BaseRequestAuthMethod } from "../requests-auth-methods/index.js";
-import { makeMiddleware } from "../types.js";
-const requireAuthUser = (methods) => makeMiddleware(
-  async (request) => {
-    request.authUser = await BaseRequestAuthMethod.process(methods, request.headers);
-    if (!request.authUser) throw new NotAuthenticatedError();
-  },
-  (route) => {
-    route.security ??= [];
-    for (const method of methods) {
-      const schemeName = method.routeSecuritySchemeName();
-      if (schemeName) route.security.push({ [schemeName]: [] });
-    }
-    route.descriptions ??= [];
-    route.descriptions.push("Requires a valid means of authentication.");
-  }
-);
-export {
-  requireAuthUser
-};

package/dist/types/server/openapi.js

@@ -1,190 +0,0 @@
-import { convert } from "@openapi-contrib/json-schema-to-openapi-schema";
-import { capitalize } from "valleyed";
-import { Instance } from "../instance/index.js";
-import { Router } from "./routes.js";
-class OpenApi {
-  constructor(config) {
-    this.config = config;
-    const instance = Instance.get();
-    const { app } = instance.settings;
-    this.#baseOpenapiDoc = {
-      openapi: "3.0.0",
-      info: {
-        title: `${app.name} ${instance.id}`,
-        version: config.openapi.docsVersion ?? ""
-      },
-      servers: config.openapi.docsBaseUrl?.map((url) => ({ url })),
-      paths: {},
-      components: {
-        schemas: {},
-        securitySchemes: {
-          Authorization: {
-            type: "apiKey",
-            name: "authorization",
-            in: "header"
-          },
-          RefreshToken: {
-            type: "apiKey",
-            name: "x-refresh-token",
-            in: "header"
-          },
-          ApiKey: {
-            type: "apiKey",
-            name: "x-api-key",
-            in: "header"
-          }
-        }
-      },
-      tags: [],
-      "x-tagGroups": []
-    };
-  }
-  #registeredTags = {};
-  #registeredTagGroups = {};
-  #baseOpenapiDoc;
-  cleanPath(path) {
-    let cleaned = path.replace(/(\/\s*)+/g, "/");
-    if (!cleaned.startsWith("/")) cleaned = `/${cleaned}`;
-    if (cleaned !== "/" && cleaned.endsWith("/")) cleaned = cleaned.slice(0, -1);
-    return cleaned;
-  }
-  async register(route, def) {
-    if (route.hide) return;
-    const tag = this.#buildTag(route.groups ?? []);
-    const cleanPath = this.cleanPath(route.path);
-    const operationId = `(${route.method.toUpperCase()}) ${cleanPath}`;
-    await this.#addRouteToOpenApiDoc(cleanPath, route.method.toLowerCase(), def, {
-      operationId,
-      summary: route.title ?? cleanPath,
-      description: route.descriptions?.join("\n\n"),
-      tags: tag ? [tag] : void 0,
-      security: route.security
-    });
-  }
-  async #addRouteToOpenApiDoc(path, method, def, methodObj) {
-    if (def.response.response?.length) {
-      methodObj.responses ??= {};
-      for (const resp of def.response.response) {
-        methodObj.responses[resp.status] ??= { description: "", content: {} };
-        const res = methodObj.responses[resp.status];
-        res.content[resp.contentType] = { schema: await convert(this.#visit(resp.schema)) };
-      }
-    }
-    if (def.response.responseHeaders?.length) {
-      methodObj.responses ??= {};
-      for (const resp of def.response.responseHeaders) {
-        methodObj.responses[resp.status] ??= { description: "", content: {} };
-        methodObj.responses[resp.status];
-        const res = methodObj.responses[resp.status];
-        res.headers = { schema: await convert(this.#visit(resp.schema)) };
-      }
-    }
-    if (def.request.body)
-      methodObj.requestBody = {
-        required: true,
-        content: {
-          "application/json": { schema: await convert(this.#visit(def.request.body)) }
-        }
-      };
-    const parameters = [];
-    const addParams = async (location, schema) => {
-      if (!schema) return;
-      const flat = this.#flattenForParameters(schema);
-      for (const schema2 of flat) {
-        if (!schema2.properties) continue;
-        for (const [name, value] of Object.entries(schema2.properties))
-          parameters.push({
-            name,
-            in: location,
-            schema: await convert(this.#visit(value)),
-            required: (schema2.required || []).includes(name)
-          });
-      }
-    };
-    await Promise.all([
-      addParams("query", def.request.query),
-      addParams("path", def.request.params),
-      addParams("header", def.request.headers)
-    ]);
-    if (parameters.length) methodObj.parameters = parameters;
-    const base = this.#baseOpenapiDoc;
-    if (!base.paths) base.paths = {};
-    if (!base.paths[path]) base.paths[path] = {};
-    base.paths[path][method] = methodObj;
-  }
-  router() {
-    const jsonPath = "/openapi.json";
-    const router = new Router({ path: this.config.openapi.docsPath ?? "/", hide: true });
-    router.get("/index.html")((req) => req.res({ body: this.#html(`.${jsonPath}`), contentType: "text/html" }));
-    router.get(jsonPath)((req) => req.res({ body: this.#baseOpenapiDoc }));
-    return router;
-  }
-  #flattenForParameters(node) {
-    const { allOf, oneOf, anyOf, ...schema } = node;
-    if (allOf) return allOf.flatMap((n) => this.#flattenForParameters(n));
-    return [schema];
-  }
-  #visit(node) {
-    if (!node || typeof node !== "object") return node;
-    if (typeof node.$refId === "string") {
-      const { $refId: id, ...rest } = node;
-      const res = this.#visit(rest);
-      if (this.#baseOpenapiDoc.components?.schemas) {
-        this.#baseOpenapiDoc.components.schemas[id] = res;
-        return { $ref: `#/components/schemas/${id}` };
-      } else return res;
-    }
-    if (Array.isArray(node)) return node.map((n) => this.#visit(n));
-    return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, this.#visit(value)]));
-  }
-  #buildTag(groups) {
-    if (!groups.length) return void 0;
-    const parsed = groups.map((g) => typeof g === "string" ? { name: g } : g);
-    const name = parsed.map((g) => g.name).join(" > ");
-    const displayName = parsed.at(-1)?.name ?? "";
-    const description = parsed.map((g) => g.description?.trim() ?? "").filter(Boolean).join("\n\n\n\n");
-    if (!this.#registeredTags[name]) {
-      this.#registeredTags[name] = true;
-      this.#baseOpenapiDoc.tags.push({ name, "x-displayName": displayName, description });
-      const tagGroups = parsed.slice(0, -1);
-      const groupName = tagGroups.map((g) => g.name).join(" > ") || "default";
-      if (!this.#registeredTagGroups[groupName]) {
-        const group = { name: groupName, tags: [] };
-        this.#baseOpenapiDoc["x-tagGroups"].push(group);
-        this.#registeredTagGroups[groupName] = group;
-      }
-      this.#registeredTagGroups[groupName].tags = [.../* @__PURE__ */ new Set([...this.#registeredTagGroups[groupName].tags, name])];
-    }
-    return name;
-  }
-  #html(jsonPath) {
-    const instance = Instance.get();
-    const title = capitalize(`${instance.settings.app.name} ${instance.id}`);
-    return `
-<!doctype html>
-<html>
-  <head>
-    <title>${title}</title>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-	<style>
-      .darklight-reference {
-        display: none;
-      }
-    </style>
-  </head>
-  <body>
-    <script id="api-reference" data-url="${jsonPath}"></script>
-    <script>
-      const configuration = { theme: 'purple' };
-      document.getElementById('api-reference').dataset.configuration = JSON.stringify(configuration);
-    </script>
-    <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference@1.38.0"></script>
-  </body>
-</html>
-`;
-  }
-}
-export {
-  OpenApi
-};

package/dist/types/server/pipes.js

@@ -1,66 +0,0 @@
-import { v } from "valleyed";
-import { EventBus } from "../events/index.js";
-import { BaseRequestAuthMethod } from "./requests-auth-methods/index.js";
-import { Methods } from "./types.js";
-const serverBasePipe = () => v.object({
-  port: v.number(),
-  cors: v.optional(
-    v.object({
-      origin: v.optional(v.or([v.array(v.string()), v.is(true)])),
-      methods: v.optional(v.array(v.in(Object.values(Methods)))),
-      credentials: v.optional(v.boolean())
-    })
-  ),
-  eventBus: v.optional(v.instanceOf(EventBus)),
-  publicPath: v.optional(v.string()),
-  healthPath: v.optional(v.string()),
-  openapi: v.defaults(
-    v.object({
-      docsVersion: v.defaults(v.string(), "1.0.0"),
-      docsBaseUrl: v.defaults(v.array(v.string()), ["/"]),
-      docsPath: v.defaults(v.string(), "/__docs")
-    }),
-    {}
-  ),
-  requests: v.defaults(
-    v.object({
-      log: v.defaults(v.boolean(), true),
-      rateLimit: v.defaults(
-        v.object({
-          enabled: v.defaults(v.boolean(), false),
-          periodInMs: v.defaults(v.number(), 60 * 60 * 1e3),
-          limit: v.defaults(v.number(), 5e3)
-        }),
-        {}
-      ),
-      slowdown: v.defaults(
-        v.object({
-          enabled: v.defaults(v.boolean(), false),
-          periodInMs: v.defaults(v.number(), 10 * 60 * 1e3),
-          delayAfter: v.defaults(v.number(), 2e3),
-          delayInMs: v.defaults(v.number(), 500)
-        }),
-        {}
-      )
-    }),
-    {}
-  ),
-  socketsAuthMethods: v.defaults(v.array(v.instanceOf(BaseRequestAuthMethod)), [])
-});
-const serverConfigPipe = () => v.discriminate((d) => d.type, {
-  fastify: v.merge(
-    serverBasePipe(),
-    v.object({
-      type: v.is("fastify")
-    })
-  ),
-  express: v.merge(
-    serverBasePipe(),
-    v.object({
-      type: v.is("express")
-    })
-  )
-});
-export {
-  serverConfigPipe
-};

package/dist/types/server/requests-auth-methods/apiKeys.js

@@ -1,20 +0,0 @@
-import { BaseRequestAuthMethod } from "./base.js";
-import { NotAuthenticatedError } from "../../errors/index.js";
-class BaseApiKeyRequestAuthMethod extends BaseRequestAuthMethod {
-  headerName;
-  constructor(headerName) {
-    super();
-    this.headerName = headerName;
-  }
-  async parse(headers) {
-    const headerValue = headers[this.headerName];
-    if (!headerValue || typeof headerValue !== "string") throw new NotAuthenticatedError();
-    return this.verify(headerValue);
-  }
-  routeSecuritySchemeName() {
-    return this.headerName;
-  }
-}
-export {
-  BaseApiKeyRequestAuthMethod
-};