equipped 5.1.11 → 5.2.0

package/dist/types/instance/index.d.ts

@@ -1,23 +1,23 @@
 import { Logger } from 'pino';
 import * as valleyed from 'valleyed';
 import { PipeOutput, ConditionalObjectKeys, PipeInput, Pipe } from 'valleyed';
-import { e as BaseTokensUtility, B as BaseApiKeysUtility, E as EquippedError } from '../requestError-DqkM5BfW.js';
+import { B as BaseRequestAuthMethod, E as EquippedError } from '../requestError-7N-ngghg.js';
 import { E as EventBus } from '../base-CfeyC14V.js';
 import { K as KafkaEventBus } from '../kafka-DCpqW_YM.js';
 import { RabbitMQEventBus } from '../events/index.js';
-import { E as ExpressServer, F as FastifyServer } from '../fastify-CDJ2WuLy.js';
+import { A as AuthUser } from '../overrides-6Hxg764S.js';
+import { E as ExpressServer, F as FastifyServer } from '../fastify-B6FUtYe9.js';
 import { InMemoryCache, RedisCache } from '../cache/index.js';
 import { M as MongoDb } from '../db-vKGTnGlO.js';
 import { RedisJob } from '../jobs/index.js';
 import '../types/index.js';
-import '../overrides-6Hxg764S.js';
-import '../base-8yVXb67P.js';
+import 'node:http2';
 import 'node:stream';
 import '@fastify/cookie';
 import 'express';
 import 'fastify';
 import 'supertest/lib/agent';
-import 'http';
+import 'node:http';
 import 'supertest';
 import 'socket.io';
 import '../core-BWUHISEy.js';
@@ -126,9 +126,13 @@ type ServerTypes = {
     express: ExpressServer;
     fastify: FastifyServer;
 };
-declare const serverTypePipe: () => valleyed.Pipe<{
-    type: "fastify" | "express";
+declare const serverTypePipe: () => valleyed.Pipe<({
     port: number;
+    cors: {
+        origin: string[] | undefined;
+        methods: ("get" | "delete" | "head" | "options" | "post" | "put" | "patch")[] | undefined;
+        credentials: boolean | undefined;
+    } | undefined;
     eventBus: EventBus | undefined;
     publicPath: string | undefined;
     healthPath: string | undefined;
@@ -151,11 +155,42 @@ declare const serverTypePipe: () => valleyed.Pipe<{
             delayInMs: number | undefined;
         } | undefined;
     } | undefined;
-    requestsAuth: {
-        tokens: BaseTokensUtility | undefined;
-        apiKey: BaseApiKeysUtility | undefined;
+    socketsAuthMethods: BaseRequestAuthMethod<AuthUser>[] | undefined;
+} & {
+    type: "fastify";
+}) | ({
+    port: number;
+    cors: {
+        origin: string[] | undefined;
+        methods: ("get" | "delete" | "head" | "options" | "post" | "put" | "patch")[] | undefined;
+        credentials: boolean | undefined;
+    } | undefined;
+    eventBus: EventBus | undefined;
+    publicPath: string | undefined;
+    healthPath: string | undefined;
+    openapi: {
+        docsVersion: string | undefined;
+        docsBaseUrl: string[] | undefined;
+        docsPath: string | undefined;
     } | undefined;
-}, ExpressServer | FastifyServer>;
+    requests: {
+        log: boolean | undefined;
+        rateLimit: {
+            enabled: boolean | undefined;
+            periodInMs: number | undefined;
+            limit: number | undefined;
+        } | undefined;
+        slowdown: {
+            enabled: boolean | undefined;
+            periodInMs: number | undefined;
+            delayAfter: number | undefined;
+            delayInMs: number | undefined;
+        } | undefined;
+    } | undefined;
+    socketsAuthMethods: BaseRequestAuthMethod<AuthUser>[] | undefined;
+} & {
+    type: "express";
+}), ExpressServer | FastifyServer>;
 
 declare class Instance {
     #private;
@@ -165,11 +200,23 @@ declare class Instance {
     alias(id: string): undefined;
     get id(): string;
     getScopedName(name: string, key?: string): string;
-    createCache<T extends PipeInput<ReturnType<typeof cachePipe>>>(input: ConditionalObjectKeys<T>): CacheTypes[T["type"]];
-    createJobs<T extends PipeInput<ReturnType<typeof jobsPipe>>>(input: ConditionalObjectKeys<T>): JobTypes[T["type"]];
-    createEventBus<T extends PipeInput<ReturnType<typeof eventBusPipe>>>(input: ConditionalObjectKeys<T>): EventBusTypes[T["type"]];
-    createDb<T extends PipeInput<ReturnType<typeof dbPipe>>>(input: ConditionalObjectKeys<T>): DbTypes[T["db"]["type"]];
-    createServer<T extends PipeInput<ReturnType<typeof serverTypePipe>>>(input: ConditionalObjectKeys<T>): ServerTypes[T["type"]];
+    createCache<T extends keyof CacheTypes>(input: ConditionalObjectKeys<Extract<PipeInput<ReturnType<typeof cachePipe>>, {
+        type: T;
+    }>>): CacheTypes[T];
+    createJobs<T extends keyof JobTypes>(input: ConditionalObjectKeys<Extract<PipeInput<ReturnType<typeof jobsPipe>>, {
+        type: T;
+    }>>): JobTypes[T];
+    createEventBus<T extends keyof EventBusTypes>(input: ConditionalObjectKeys<Extract<PipeInput<ReturnType<typeof eventBusPipe>>, {
+        type: T;
+    }>>): EventBusTypes[T];
+    createDb<T extends keyof DbTypes>(input: ConditionalObjectKeys<Extract<PipeInput<ReturnType<typeof dbPipe>>, {
+        db: {
+            type: T;
+        };
+    }>>): DbTypes[T];
+    createServer<T extends keyof ServerTypes>(input: ConditionalObjectKeys<Extract<PipeInput<ReturnType<typeof serverTypePipe>>, {
+        type: T;
+    }>>): ServerTypes[T];
     start(): Promise<void>;
     static envs<E extends object>(envsPipe: Pipe<unknown, E>): E;
     static create(settings: SettingsInput): Instance;

package/dist/types/{requestError-DqkM5BfW.d.ts → requestError-7N-ngghg.d.ts}

@@ -2,8 +2,8 @@ import * as valleyed from 'valleyed';
 import { PipeOutput, Pipe, Prettify, IsInTypeList, PipeInput, DistributiveOmit } from 'valleyed';
 import { Enum } from './types/index.js';
 import { E as EventBus } from './base-CfeyC14V.js';
-import { A as AuthUser, a as RefreshUser } from './overrides-6Hxg764S.js';
-import { C as Cache } from './base-8yVXb67P.js';
+import { A as AuthUser } from './overrides-6Hxg764S.js';
+import { IncomingHttpHeaders } from 'node:http2';
 import { Readable } from 'node:stream';
 import { SerializeOptions } from '@fastify/cookie';
 
@@ -14,57 +14,23 @@ declare class EquippedError extends Error {
     constructor(message: string, context: Record<string, unknown>, cause?: unknown | undefined);
 }
 
-declare abstract class BaseApiKeysUtility {
-    abstract verifyApiKey(apiKey: string): Promise<AuthUser>;
+declare abstract class BaseRequestAuthMethod<T extends {
+    id: string;
+}> {
+    abstract parse(headers: IncomingHttpHeaders): Promise<T>;
+    abstract routeSecuritySchemeName(): string | null;
+    static process<T extends {
+        id: string;
+    }>(methods: BaseRequestAuthMethod<T>[], headers: IncomingHttpHeaders): Promise<T | null>;
 }
 
-declare abstract class BaseTokensUtility {
-    abstract createAccessToken(payload: AuthUser): Promise<string>;
-    abstract createRefreshToken(payload: RefreshUser): Promise<string>;
-    abstract verifyAccessToken(token: string): Promise<AuthUser>;
-    abstract verifyRefreshToken(token: string): Promise<RefreshUser>;
-    abstract retrieveAccessTokenFor(userId: string): Promise<string | null>;
-    abstract retrieveRefreshTokenFor(userId: string): Promise<string | null>;
-    abstract deleteAccessTokenFor(userId: string): Promise<void>;
-    abstract deleteRefreshTokenFor(userId: string): Promise<void>;
-    extractAccessTokenValue(headerValue: string): string;
-    exchangeTokens(tokens: {
-        accessToken: string;
-        refreshToken: string;
-    }, getPayload: (id: string) => Promise<{
-        access: AuthUser;
-        refresh: RefreshUser;
-    }>): Promise<{
-        accessToken: string;
-        refreshToken: string;
-    }>;
-}
-type CacheTokensUtilityOptions = {
-    cache: () => Cache;
-    accessTokenKey?: string;
-    refreshTokenKey?: string;
-    accessTokenTTL?: number;
-    refreshTokenTTL?: number;
-    accessTokenPrefix?: string;
-    refreshTokenPrefix?: string;
-};
-declare class CacheTokensUtility extends BaseTokensUtility {
-    #private;
-    private options;
-    constructor(options: CacheTokensUtilityOptions);
-    createAccessToken(payload: AuthUser): Promise<string>;
-    createRefreshToken(payload: RefreshUser): Promise<string>;
-    verifyAccessToken(authHeader: string): Promise<AuthUser>;
-    verifyRefreshToken(token: string): Promise<RefreshUser>;
-    retrieveAccessTokenFor(userId: string): Promise<string | null>;
-    retrieveRefreshTokenFor(userId: string): Promise<string | null>;
-    deleteAccessTokenFor(userId: string): Promise<void>;
-    deleteRefreshTokenFor(userId: string): Promise<void>;
-}
-
-declare const serverConfigPipe: () => valleyed.Pipe<{
-    type: "fastify" | "express";
+declare const serverConfigPipe: () => valleyed.Pipe<({
     port: number;
+    cors: {
+        origin: string[] | undefined;
+        methods: ("get" | "delete" | "head" | "options" | "post" | "put" | "patch")[] | undefined;
+        credentials: boolean | undefined;
+    } | undefined;
     eventBus: EventBus | undefined;
     publicPath: string | undefined;
     healthPath: string | undefined;
@@ -87,13 +53,48 @@ declare const serverConfigPipe: () => valleyed.Pipe<{
             delayInMs: number | undefined;
         } | undefined;
     } | undefined;
-    requestsAuth: {
-        tokens: BaseTokensUtility | undefined;
-        apiKey: BaseApiKeysUtility | undefined;
+    socketsAuthMethods: BaseRequestAuthMethod<AuthUser>[] | undefined;
+} & {
+    type: "fastify";
+}) | ({
+    port: number;
+    cors: {
+        origin: string[] | undefined;
+        methods: ("get" | "delete" | "head" | "options" | "post" | "put" | "patch")[] | undefined;
+        credentials: boolean | undefined;
+    } | undefined;
+    eventBus: EventBus | undefined;
+    publicPath: string | undefined;
+    healthPath: string | undefined;
+    openapi: {
+        docsVersion: string | undefined;
+        docsBaseUrl: string[] | undefined;
+        docsPath: string | undefined;
+    } | undefined;
+    requests: {
+        log: boolean | undefined;
+        rateLimit: {
+            enabled: boolean | undefined;
+            periodInMs: number | undefined;
+            limit: number | undefined;
+        } | undefined;
+        slowdown: {
+            enabled: boolean | undefined;
+            periodInMs: number | undefined;
+            delayAfter: number | undefined;
+            delayInMs: number | undefined;
+        } | undefined;
     } | undefined;
-}, {
-    type: "fastify" | "express";
+    socketsAuthMethods: BaseRequestAuthMethod<AuthUser>[] | undefined;
+} & {
+    type: "express";
+}), ({
     port: number;
+    cors: {
+        origin: string[] | undefined;
+        methods: ("get" | "delete" | "head" | "options" | "post" | "put" | "patch")[] | undefined;
+        credentials: boolean | undefined;
+    } | undefined;
     eventBus: EventBus | undefined;
     publicPath: string | undefined;
     healthPath: string | undefined;
@@ -116,11 +117,42 @@ declare const serverConfigPipe: () => valleyed.Pipe<{
             delayInMs: number;
         };
     };
-    requestsAuth: {
-        tokens: BaseTokensUtility | undefined;
-        apiKey: BaseApiKeysUtility | undefined;
+    socketsAuthMethods: BaseRequestAuthMethod<AuthUser>[];
+} & {
+    type: "fastify";
+}) | ({
+    port: number;
+    cors: {
+        origin: string[] | undefined;
+        methods: ("get" | "delete" | "head" | "options" | "post" | "put" | "patch")[] | undefined;
+        credentials: boolean | undefined;
+    } | undefined;
+    eventBus: EventBus | undefined;
+    publicPath: string | undefined;
+    healthPath: string | undefined;
+    openapi: {
+        docsVersion: string;
+        docsBaseUrl: string[];
+        docsPath: string;
     };
-}>;
+    requests: {
+        log: boolean;
+        rateLimit: {
+            enabled: boolean;
+            periodInMs: number;
+            limit: number;
+        };
+        slowdown: {
+            enabled: boolean;
+            periodInMs: number;
+            delayAfter: number;
+            delayInMs: number;
+        };
+    };
+    socketsAuthMethods: BaseRequestAuthMethod<AuthUser>[];
+} & {
+    type: "express";
+})>;
 type ServerConfig = PipeOutput<ReturnType<typeof serverConfigPipe>>;
 
 declare const Methods: {
@@ -141,7 +173,7 @@ declare const StatusCodes: {
     readonly NotFound: 404;
     readonly ValidationError: 422;
     readonly TooManyRequests: 429;
-    readonly AuthorizationExpired: 461;
+    readonly TokenExpired: 461;
 };
 type MethodsEnum = Enum<typeof Methods>;
 type StatusCodesEnum = Enum<typeof StatusCodes>;
@@ -167,7 +199,6 @@ type RouteDef = {
     responseCookies?: Pipe<DefaultCookies, DefaultCookies>;
     defaultStatusCode?: StatusCodesEnum;
     defaultContentType?: string;
-    context?: (req: Request<RouteDefToReqRes<RouteDef>>) => Awaitable<Record<string, unknown>>;
 };
 type RouteGroup = {
     name: string;
@@ -209,7 +240,6 @@ type RouteDefToReqRes<T extends RouteDef> = Prettify<{
     responseCookies: PipeOutput<GetApiPart<T, 'responseCookies'>>;
     statusCode: GetApiPart<T, 'defaultStatusCode'>;
     contentType: GetApiPart<T, 'defaultContentType'>;
-    context: Awaited<ReturnType<GetApiPart<T, 'context'>>>;
 }>;
 type Awaitable<T> = Promise<T> | T;
 type Res<T extends RouteDefToReqRes<any>> = Awaitable<IsInTypeList<T['statusCode'], [StatusCodesEnum, 200]> extends true ? IsInTypeList<T['responseHeaders'], [DefaultHeaders]> extends true ? IsInTypeList<T['responseCookies'], [DefaultCookies]> extends true ? Response<T> | T['response'] : Response<T> : Response<T> : Response<T>>;
@@ -234,12 +264,6 @@ declare const makeErrorMiddleware: <Def extends RouteDef>(...args: Parameters<ty
     onSetup: HandlerSetup<Def> | undefined;
 };
 
-type HeaderKeys = 'Authorization' | 'RefreshToken' | 'ApiKey' | 'Referer' | 'ContentType' | 'UserAgent';
-type ReqUser<T> = {
-    error?: RequestError;
-    value?: T;
-};
-type FallbackHeadersType = Record<string, string | string[] | undefined>;
 type CookieVal<C extends DefaultCookies> = {
     [K in keyof C]: SerializeOptions & {
         value: C[K];
@@ -252,26 +276,19 @@ declare class Request<Def extends RouteDefToReqRes<any>> {
     body: Def['body'];
     params: Def['params'];
     query: Def['query'];
-    headers: Record<HeaderKeys, string | undefined> & Def['requestHeaders'] & FallbackHeadersType;
-    context: Def['context'];
+    headers: IncomingHttpHeaders & Def['requestHeaders'];
     cookies: Record<string, string | undefined> & Def['requestCookies'];
-    users: {
-        access: ReqUser<AuthUser>;
-        refresh: ReqUser<RefreshUser>;
-        apiKey: ReqUser<AuthUser>;
-    };
-    authUser?: AuthUser;
-    constructor({ ip, body, cookies, params, query, method, path, context, headers, files, }: {
+    authUser: AuthUser | null;
+    constructor({ ip, body, cookies, params, query, method, path, headers, files, }: {
         ip: string | undefined;
         body: Def['body'];
         params: Def['params'];
         query: Def['query'];
         cookies: Record<string, string | undefined> & Def['requestCookies'];
-        headers: Record<HeaderKeys, string | undefined> & Def['requestHeaders'] & FallbackHeadersType;
+        headers: IncomingHttpHeaders;
         files: Record<string, IncomingFile[]>;
         method: MethodsEnum;
         path: string;
-        context: Def['context'];
     });
     pipe(stream: Readable, opts?: {
         headers?: Def['responseHeaders'];
@@ -337,4 +354,4 @@ declare abstract class RequestError extends EquippedError {
     }[], cause?: unknown);
 }
 
-export { BaseApiKeysUtility as B, CacheTokensUtility as C, type DefaultHeaders as D, EquippedError as E, type IncomingFile as I, Methods as M, Request as R, type ServerConfig as S, type RouteDefToReqRes as a, type RouteDef as b, type Route as c, Response as d, BaseTokensUtility as e, StatusCodes as f, type MethodsEnum as g, type StatusCodesEnum as h, type DefaultCookies as i, type RouteConfig as j, type RouterConfig as k, type MergeRouteDefs as l, type RouteDefHandler as m, makeMiddleware as n, makeErrorMiddleware as o, RequestError as p, serverConfigPipe as s };
+export { BaseRequestAuthMethod as B, type CookieVal as C, type DefaultHeaders as D, EquippedError as E, type IncomingFile as I, Methods as M, RequestError as R, type ServerConfig as S, Request as a, Response as b, type RouteDefToReqRes as c, type RouteDef as d, type Route as e, StatusCodes as f, type MethodsEnum as g, type StatusCodesEnum as h, type DefaultCookies as i, type RouteConfig as j, type RouterConfig as k, type MergeRouteDefs as l, type RouteDefHandler as m, makeMiddleware as n, makeErrorMiddleware as o, serverConfigPipe as s };

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

@@ -1,3 +1,4 @@
+import {} from "cors";
 import { Server as SocketServer } from "socket.io";
 import supertest from "supertest";
 import { PipeError, v } from "valleyed";
@@ -5,7 +6,6 @@ import { EquippedError, NotFoundError, RequestError } from "../../errors/index.j
 import { Instance } from "../../instance/index.js";
 import { pipeErrorToValidationError } from "../../validations/index.js";
 import { requestLocalStorage, responseLocalStorage } from "../../validations/valleyed.js";
-import { parseAuthUser } from "../middlewares/parseAuthUser.js";
 import { OpenApi } from "../openapi.js";
 import { Response } from "../requests.js";
 import { Router } from "../routes.js";
@@ -34,10 +34,13 @@ class Server {
   #openapi;
   socket;
   server;
-  cors = {
-    origin: "*",
-    methods: Object.values(Methods).filter((m) => m !== Methods.options).map((m) => m.toUpperCase())
-  };
+  get cors() {
+    return {
+      origin: 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));
   }
@@ -48,7 +51,6 @@ class Server {
         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.unshift(parseAuthUser);
         middlewares.forEach((m) => m.onSetup?.(route));
         onError?.onSetup?.(route);
         const { validateRequest, validateResponse, jsonSchema } = this.#resolveSchema(method, schema);
@@ -118,8 +120,6 @@ class Server {
     v.compile(responsePipe, { allErrors: true });
     const validateRequest = async (request) => {
       if (!Object.keys(requestPipeDefs)) return request;
-      const context = schema.context ? await schema.context(request) : {};
-      request.context = context;
       const validity = requestLocalStorage.run(
         request,
         () => v.validate(requestPipe, {
@@ -146,7 +146,7 @@ class Server {
         response,
         () => v.validate(responsePipe, {
           responseHeaders: response.headers,
-          responseCookies: response.cookies,
+          responseCookies: Object.fromEntries(Object.entries(response.cookies).map(([key, val]) => [key, val.value])),
           response: response.body
         })
       );

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

@@ -18,16 +18,6 @@ class ExpressServer extends Server {
     const instance = Instance.get();
     super(http.createServer(app), config, {
       parseRequest: async (req) => {
-        const allHeaders = Object.fromEntries(Object.entries(req.headers).map(([key, val]) => [key, val ?? null]));
-        const headers = {
-          ...allHeaders,
-          Authorization: req.get("authorization"),
-          RefreshToken: req.get("x-refresh-token"),
-          ApiKey: req.get("x-api-key"),
-          ContentType: req.get("content-type"),
-          Referer: req.get("referer"),
-          UserAgent: req.get("user-agent")
-        };
         const files = Object.fromEntries(
           await Promise.all(
             Object.entries(req.files ?? {}).map(async ([key, file]) => {
@@ -54,9 +44,8 @@ class ExpressServer extends Server {
           query: req.query ?? {},
           method: req.method,
           path: req.path,
-          headers,
-          files,
-          context: {}
+          headers: req.headers,
+          files
         });
       },
       handleResponse: async (res, response) => {

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

@@ -33,16 +33,6 @@ class FastifyServer extends Server {
     });
     super(app.server, config, {
       parseRequest: async (req) => {
-        const allHeaders = Object.fromEntries(Object.entries(req.headers).map(([key, val]) => [key, val ?? null]));
-        const headers = {
-          ...allHeaders,
-          Authorization: req.headers["authorization"]?.toString(),
-          RefreshToken: req.headers["x-refresh-token"]?.toString(),
-          ApiKey: req.headers["x-api-key"]?.toString(),
-          ContentType: req.headers["content-type"]?.toString(),
-          Referer: req.headers["referer"]?.toString(),
-          UserAgent: req.headers["user-agent"]?.toString()
-        };
         const { body, files } = excludeBufferKeys(req.body ?? {});
         return new Request({
           ip: req.ip,
@@ -52,9 +42,8 @@ class FastifyServer extends Server {
           query: req.query ?? {},
           method: req.method,
           path: req.url,
-          headers,
-          files,
-          context: {}
+          headers: req.headers,
+          files
         });
       },
       handleResponse: async (res, response) => {

package/dist/types/server/index.d.ts

@@ -1,38 +1,80 @@
-export { E as ExpressServer, F as FastifyServer, O as OnJoinFn, R as Router, S as Server, a as SocketCallbacks, b as SocketEmitter } from '../fastify-CDJ2WuLy.js';
-import { R as Request, a as RouteDefToReqRes, b as RouteDef, S as ServerConfig, c as Route } from '../requestError-DqkM5BfW.js';
-export { B as BaseApiKeysUtility, e as BaseTokensUtility, C as CacheTokensUtility, i as DefaultCookies, D as DefaultHeaders, I as IncomingFile, l as MergeRouteDefs, M as Methods, g as MethodsEnum, d as Response, j as RouteConfig, m as RouteDefHandler, k as RouterConfig, f as StatusCodes, h as StatusCodesEnum, o as makeErrorMiddleware, n as makeMiddleware, s as serverConfigPipe } from '../requestError-DqkM5BfW.js';
+export { E as ExpressServer, F as FastifyServer, O as OnJoinFn, R as Router, S as Server, a as SocketCallbacks, b as SocketEmitter } from '../fastify-B6FUtYe9.js';
+import { B as BaseRequestAuthMethod, a as Request, c as RouteDefToReqRes, d as RouteDef, S as ServerConfig, e as Route } from '../requestError-7N-ngghg.js';
+export { C as CookieVal, i as DefaultCookies, D as DefaultHeaders, I as IncomingFile, l as MergeRouteDefs, M as Methods, g as MethodsEnum, b as Response, j as RouteConfig, m as RouteDefHandler, k as RouterConfig, f as StatusCodes, h as StatusCodesEnum, o as makeErrorMiddleware, n as makeMiddleware, s as serverConfigPipe } from '../requestError-7N-ngghg.js';
+import { A as AuthUser } from '../overrides-6Hxg764S.js';
+import { IncomingHttpHeaders } from 'node:http2';
 import 'express';
 import 'fastify';
 import 'supertest/lib/agent';
-import 'http';
+import 'node:http';
 import 'supertest';
 import 'socket.io';
 import '../core-BWUHISEy.js';
 import 'mongodb';
 import 'valleyed';
 import '../kafka-DCpqW_YM.js';
-import '../overrides-6Hxg764S.js';
 import '../base-CfeyC14V.js';
 import '../types/index.js';
-import '../base-8yVXb67P.js';
 import 'node:stream';
 import '@fastify/cookie';
 
-declare const requireAuthUser: {
-    cb: (req: Request<RouteDefToReqRes<RouteDef>>, config: ServerConfig) => void | Promise<void>;
-    onSetup: ((route: Route<RouteDef>) => void) | undefined;
-};
-declare const requireAuthorizationUser: {
-    cb: (req: Request<RouteDefToReqRes<RouteDef>>, config: ServerConfig) => void | Promise<void>;
-    onSetup: ((route: Route<RouteDef>) => void) | undefined;
-};
-declare const requireApiKeyUser: {
-    cb: (req: Request<RouteDefToReqRes<RouteDef>>, config: ServerConfig) => void | Promise<void>;
-    onSetup: ((route: Route<RouteDef>) => void) | undefined;
-};
-declare const requireRefreshTokenUser: {
+declare abstract class BaseApiKeyRequestAuthMethod<T extends {
+    id: string;
+}> extends BaseRequestAuthMethod<T> {
+    protected readonly headerName: string;
+    protected abstract verify(apiKey: string): Promise<T>;
+    constructor(headerName: string);
+    parse(headers: IncomingHttpHeaders): Promise<T>;
+    routeSecuritySchemeName(): string;
+}
+
+interface BaseJwtRequestAuthMethodOptions {
+    signingKey: string;
+    storageTTL: number;
+    storagePrefix?: string;
+    enforceSingleSession?: boolean;
+}
+declare abstract class BaseJwtRequestAuthMethod<T extends {
+    id: string;
+}> extends BaseRequestAuthMethod<T> {
+    #private;
+    protected readonly options: BaseJwtRequestAuthMethodOptions;
+    protected abstract parseHeader(headers: IncomingHttpHeaders): Promise<string>;
+    protected abstract store(key: string, token: string, ttl: number): Promise<void>;
+    protected abstract retrieve(key: string): Promise<string | null>;
+    protected abstract delete(key: string): Promise<void>;
+    constructor(options: BaseJwtRequestAuthMethodOptions);
+    createToken(payload: T): Promise<string>;
+    parse(headers: IncomingHttpHeaders): Promise<T>;
+    retrieveFor(userId: string): Promise<string | null>;
+    deleteFor(userId: string): Promise<void>;
+}
+interface BaseJwtHeaderRequestAuthMethodOptions<T extends string> extends BaseJwtRequestAuthMethodOptions {
+    headerName: T;
+}
+declare abstract class BaseJwtHeaderRequestAuthMethod<T extends {
+    id: string;
+}, Name extends string = string> extends BaseJwtRequestAuthMethod<T> {
+    protected readonly options: BaseJwtHeaderRequestAuthMethodOptions<Name>;
+    constructor(options: BaseJwtHeaderRequestAuthMethodOptions<Name>);
+    parseHeader(headers: IncomingHttpHeaders): Promise<string>;
+    routeSecuritySchemeName(): Name;
+}
+interface BaseJwtCookieRequestAuthMethodOptions<T extends string> extends BaseJwtRequestAuthMethodOptions {
+    cookieName: T;
+}
+declare abstract class BaseJwtCookieRequestAuthMethod<T extends {
+    id: string;
+}, Name extends string = string> extends BaseJwtRequestAuthMethod<T> {
+    protected readonly options: BaseJwtCookieRequestAuthMethodOptions<Name>;
+    constructor(options: BaseJwtCookieRequestAuthMethodOptions<Name>);
+    parseHeader(headers: IncomingHttpHeaders): Promise<string>;
+    routeSecuritySchemeName(): string;
+}
+
+declare const requireAuthUser: (methods: BaseRequestAuthMethod<AuthUser>[]) => {
     cb: (req: Request<RouteDefToReqRes<RouteDef>>, config: ServerConfig) => void | Promise<void>;
     onSetup: ((route: Route<RouteDef>) => void) | undefined;
 };
 
-export { Request, Route, RouteDef, RouteDefToReqRes, ServerConfig, requireApiKeyUser, requireAuthUser, requireAuthorizationUser, requireRefreshTokenUser };
+export { BaseApiKeyRequestAuthMethod, BaseJwtCookieRequestAuthMethod, BaseJwtHeaderRequestAuthMethod, BaseJwtRequestAuthMethod, type BaseJwtRequestAuthMethodOptions, BaseRequestAuthMethod, Request, Route, RouteDef, RouteDefToReqRes, ServerConfig, requireAuthUser };

package/dist/types/server/index.js

@@ -4,6 +4,6 @@ export * from "./impls/fastify.js";
 export * from "./middlewares/index.js";
 export * from "./pipes.js";
 export * from "./requests.js";
-export * from "./requests-auth/index.js";
+export * from "./requests-auth-methods/index.js";
 export * from "./routes.js";
 export * from "./types.js";