equipped 5.2.8 → 5.3.0-alpha.0

package/dist/types/{requestError-C2PNWUrt.d.ts → requestError-DdaL8hc3.d.ts}

@@ -1,3 +1,4 @@
+import { E as EquippedError } from './equippedError-Cmo60Kn-.js';
 import { Pipe, Prettify, PipeOutput, IsInTypeList, PipeInput, DistributiveOmit } from 'valleyed';
 import { Enum } from './types/index.js';
 import { IncomingHttpHeaders } from 'node:http2';
@@ -5,13 +6,6 @@ import { Readable } from 'node:stream';
 import { SerializeOptions } from '@fastify/cookie';
 import { A as AuthUser } from './overrides-6Hxg764S.js';
 
-declare class EquippedError extends Error {
-    readonly message: string;
-    readonly context: Record<string, unknown>;
-    readonly cause?: unknown | undefined;
-    constructor(message: string, context: Record<string, unknown>, cause?: unknown | undefined);
-}
-
 declare const Methods: {
     readonly head: "head";
     readonly get: "get";
@@ -217,4 +211,4 @@ declare abstract class RequestError extends EquippedError {
     }[], cause?: unknown);
 }
 
-export { type CookieVal as C, type DefaultHeaders as D, EquippedError as E, type IncomingFile as I, Methods as M, RequestError as R, StatusCodes as S, Request as a, Response as b, type RouteDefToReqRes as c, type RouteDef as d, type Route as e, type MethodsEnum as f, type StatusCodesEnum as g, type DefaultCookies as h, type RouteConfig as i, type RouterConfig as j, type MergeRouteDefs as k, type RouteDefHandler as l, makeMiddleware as m, makeResponseMiddleware as n, makeErrorMiddleware as o };
+export { type CookieVal as C, type DefaultHeaders as D, type IncomingFile as I, type MethodsEnum as M, Request as R, StatusCodes as S, Response as a, RequestError as b, type RouteDefToReqRes as c, type RouteDef as d, type Route as e, Methods as f, type StatusCodesEnum as g, type DefaultCookies as h, type RouteConfig as i, type RouterConfig as j, type MergeRouteDefs as k, type RouteDefHandler as l, makeMiddleware as m, makeResponseMiddleware as n, makeErrorMiddleware as o };

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

@@ -0,0 +1,194 @@
+import { B as BaseRequestAuthMethod, S as Server } from '../../../base-3PpBAx1K.js';
+import { A as AuthUser } from '../../../overrides-6Hxg764S.js';
+import { R as Request, a as Response, M as MethodsEnum } from '../../../requestError-DdaL8hc3.js';
+import { EventBus } from '../../../events/index.js';
+import 'node:http';
+import '@fastify/cors';
+import 'cors';
+import 'supertest/lib/agent';
+import 'valleyed';
+import 'node:http2';
+import 'socket.io';
+import '../../../core-tNlIMH9Y.js';
+import 'mongodb';
+import '../../../events/adapters/kafka/index.js';
+import '../../../equippedError-Cmo60Kn-.js';
+import '../../../types/index.js';
+import 'node:stream';
+import '@fastify/cookie';
+
+declare const ExpressServer_base: (abstract new (validated: {
+    port: number;
+    cors: {
+        origin: true | string[] | undefined;
+        methods: ("head" | "get" | "post" | "put" | "patch" | "delete" | "options")[] | 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>[];
+}) => Server & {
+    readonly config: {
+        port: number;
+        cors: {
+            origin: true | string[] | undefined;
+            methods: ("head" | "get" | "post" | "put" | "patch" | "delete" | "options")[] | 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>[];
+    };
+}) & {
+    readonly Config: {
+        port: number;
+        cors: {
+            origin: true | string[] | undefined;
+            methods: ("head" | "get" | "post" | "put" | "patch" | "delete" | "options")[] | 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>[];
+    };
+    create<This extends Function & {
+        prototype: any;
+    }>(this: This, input: {
+        port: number;
+        cors?: {
+            origin?: true | string[] | undefined;
+            methods?: ("head" | "get" | "post" | "put" | "patch" | "delete" | "options")[] | undefined;
+            credentials?: boolean | undefined;
+        } | undefined;
+        eventBus?: {
+            stream: {};
+        } | 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;
+        socketsAuthMethods?: {
+            parse: {};
+            routeSecuritySchemeName: {};
+        }[] | undefined;
+    }, ...args: ConstructorParameters<This & (abstract new (...args: any[]) => any)> extends [{
+        port: number;
+        cors: {
+            origin: true | string[] | undefined;
+            methods: ("head" | "get" | "post" | "put" | "patch" | "delete" | "options")[] | 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>[];
+    }, ...infer R] ? R : never): This["prototype"];
+};
+declare class ExpressServer extends ExpressServer_base {
+    #private;
+    protected constructor(config: typeof ExpressServer.Config);
+    protected parseRequest(req: any): Promise<Request<any>>;
+    protected handleResponse(res: any, response: Response<any>): Promise<void>;
+    protected registerRoute(method: MethodsEnum, path: string, cb: (req: any, res: any) => Promise<void>): void;
+    protected registerErrorHandler(cb: (error: Error, req: any, res: any) => Promise<void>): void;
+    protected registerNotFoundHandler(cb: (req: any, res: any) => Promise<void>): void;
+    protected startServer(port: number): Promise<boolean>;
+}
+
+export { ExpressServer };

package/dist/types/server/adapters/express/index.js

@@ -0,0 +1,125 @@
+import {
+  Instance,
+  Request,
+  Server,
+  StatusCodes,
+  configurable,
+  getMediaDuration,
+  serverConfigPipe
+} from "../../../chunk-32DMHN3G.js";
+import "../../../chunk-KZKFYO4V.js";
+import "../../../chunk-MLKGABMK.js";
+
+// src/server/adapters/express/index.ts
+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";
+var ExpressServer = class extends configurable(serverConfigPipe, Server) {
+  #app;
+  #httpServer;
+  constructor(config) {
+    super(config);
+    const app = express();
+    const instance = Instance.get();
+    const httpServer = http.createServer(app);
+    this.#app = app;
+    this.#httpServer = httpServer;
+    this.setup(httpServer, config);
+    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" }])
+        })
+      );
+  }
+  async parseRequest(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
+    });
+  }
+  async handleResponse(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) {
+    this.#app[method]?.(path, async (req, res) => cb(req, res));
+  }
+  registerErrorHandler(cb) {
+    this.#app.use(async (err, req, res, _next) => cb(err, req, res));
+  }
+  registerNotFoundHandler(cb) {
+    this.#app.use(async (req, res, _next) => cb(req, res));
+  }
+  startServer(port) {
+    return new Promise((resolve, reject) => {
+      try {
+        const server = this.#httpServer.listen({ host: "0.0.0.0", port }, async () => resolve(true));
+        Instance.on("close", server.close);
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+};
+export {
+  ExpressServer
+};

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

@@ -0,0 +1,219 @@
+import { B as BaseRequestAuthMethod, S as Server } from '../../../base-3PpBAx1K.js';
+import { A as AuthUser } from '../../../overrides-6Hxg764S.js';
+import { R as Request, a as Response, M as MethodsEnum } from '../../../requestError-DdaL8hc3.js';
+import { EventBus } from '../../../events/index.js';
+import 'node:http';
+import '@fastify/cors';
+import 'cors';
+import 'supertest/lib/agent';
+import 'valleyed';
+import 'node:http2';
+import 'socket.io';
+import '../../../core-tNlIMH9Y.js';
+import 'mongodb';
+import '../../../events/adapters/kafka/index.js';
+import '../../../equippedError-Cmo60Kn-.js';
+import '../../../types/index.js';
+import 'node:stream';
+import '@fastify/cookie';
+
+declare const FastifyServer_base: (abstract new (validated: {
+    port: number;
+    cors: {
+        origin: true | string[] | undefined;
+        methods: ("head" | "get" | "post" | "put" | "patch" | "delete" | "options")[] | 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>[];
+}) => Server & {
+    readonly config: {
+        port: number;
+        cors: {
+            origin: true | string[] | undefined;
+            methods: ("head" | "get" | "post" | "put" | "patch" | "delete" | "options")[] | 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>[];
+    };
+}) & {
+    readonly Config: {
+        port: number;
+        cors: {
+            origin: true | string[] | undefined;
+            methods: ("head" | "get" | "post" | "put" | "patch" | "delete" | "options")[] | 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>[];
+    };
+    create<This extends Function & {
+        prototype: any;
+    }>(this: This, input: {
+        port: number;
+        cors?: {
+            origin?: true | string[] | undefined;
+            methods?: ("head" | "get" | "post" | "put" | "patch" | "delete" | "options")[] | undefined;
+            credentials?: boolean | undefined;
+        } | undefined;
+        eventBus?: {
+            stream: {};
+        } | 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;
+        socketsAuthMethods?: {
+            parse: {};
+            routeSecuritySchemeName: {};
+        }[] | undefined;
+    }, ...args: ConstructorParameters<This & (abstract new (...args: any[]) => any)> extends [{
+        port: number;
+        cors: {
+            origin: true | string[] | undefined;
+            methods: ("head" | "get" | "post" | "put" | "patch" | "delete" | "options")[] | 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>[];
+    }, ...infer R] ? R : never): This["prototype"];
+};
+declare class FastifyServer extends FastifyServer_base {
+    #private;
+    protected constructor(config: typeof FastifyServer.Config);
+    protected parseRequest(req: any): Promise<Request<{
+        body: {
+            [x: string]: unknown;
+        };
+        params: {
+            [x: string]: string | string[] | undefined;
+        };
+        requestHeaders: {
+            [x: string]: string | string[] | undefined;
+        };
+        requestCookies: {
+            [x: string]: string | undefined;
+        };
+        query: {
+            [x: string]: unknown;
+        };
+        response: unknown;
+        responseHeaders: {
+            [x: string]: string | string[] | undefined;
+        };
+        responseCookies: {
+            [x: string]: string | undefined;
+        };
+        statusCode: 200 | 302 | 400 | 401 | 403 | 404 | 422 | 429 | 461;
+        contentType: string;
+    }>>;
+    protected handleResponse(res: any, response: Response<any>): Promise<void>;
+    protected registerRoute(method: MethodsEnum, path: string, cb: (req: any, res: any) => Promise<void>): void;
+    protected registerErrorHandler(cb: (error: Error, req: any, res: any) => Promise<void>): void;
+    protected registerNotFoundHandler(cb: (req: any, res: any) => Promise<void>): void;
+    protected startServer(port: number): Promise<boolean>;
+}
+
+export { FastifyServer };

package/dist/{esm/server/impls/fastify.mjs → types/server/adapters/fastify/index.js}

@@ -1,3 +1,17 @@
+import {
+  Instance,
+  Request,
+  Server,
+  StatusCodes,
+  ValidationError,
+  configurable,
+  getMediaDuration,
+  serverConfigPipe
+} from "../../../chunk-32DMHN3G.js";
+import "../../../chunk-KZKFYO4V.js";
+import "../../../chunk-MLKGABMK.js";
+
+// src/server/adapters/fastify/index.ts
 import fastifyCookie from "@fastify/cookie";
 import fastifyCors from "@fastify/cors";
 import fastifyFormBody from "@fastify/formbody";
@@ -7,14 +21,10 @@ import fastifyRateLimit from "@fastify/rate-limit";
 import fastifyStatic from "@fastify/static";
 import Fastify from "fastify";
 import qs from "qs";
-import { ValidationError } from "../../errors/index.mjs";
-import { Instance } from "../../instance/index.mjs";
-import { getMediaDuration } from "../../utilities/index.mjs";
-import { Request } from "../requests.mjs";
-import { StatusCodes } from "../types.mjs";
-import { Server } from "./base.mjs";
-class FastifyServer extends Server {
+var FastifyServer = class extends configurable(serverConfigPipe, Server) {
+  #app;
   constructor(config) {
+    super(config);
     const instance = Instance.get();
     const app = Fastify({
       disableRequestLogging: !config.requests.log,
@@ -31,43 +41,8 @@ class FastifyServer extends Server {
         }))
       )
     });
-    super(app.server, config, {
-      parseRequest: async (req) => {
-        const { body, files } = excludeBufferKeys(req.body ?? {});
-        return new Request({
-          ip: req.ip,
-          body,
-          cookies: req.cookies ?? {},
-          params: req.params ?? {},
-          query: req.query ?? {},
-          method: req.method,
-          path: req.url,
-          headers: req.headers,
-          files
-        });
-      },
-      handleResponse: async (res, response) => {
-        for (const [key, { value, ...opts }] of Object.entries(response.cookies)) res = res.setCookie(key, value, opts);
-        await res.status(response.status).headers(response.headers).send(response.body);
-      },
-      registerRoute: (method, path, cb) => {
-        app.register(async (inst) => {
-          inst.route({ url: path, method, handler: cb });
-        });
-      },
-      registerErrorHandler: (cb) => {
-        app.setErrorHandler(cb);
-      },
-      registerNotFoundHandler: (cb) => {
-        app.setNotFoundHandler(cb);
-      },
-      start: async (port) => {
-        await app.ready();
-        await app.listen({ port, host: "0.0.0.0" });
-        Instance.on("close", app.close, 1);
-        return true;
-      }
-    });
+    this.#app = app;
+    this.setup(app.server, config);
     app.decorateRequest("savedReq", null);
     app.setValidatorCompiler(() => () => true);
     app.setSerializerCompiler(() => (data) => JSON.stringify(data));
@@ -103,7 +78,42 @@ class FastifyServer extends Server {
         })
       });
   }
-}
+  async parseRequest(req) {
+    const { body, files } = excludeBufferKeys(req.body ?? {});
+    return new Request({
+      ip: req.ip,
+      body,
+      cookies: req.cookies ?? {},
+      params: req.params ?? {},
+      query: req.query ?? {},
+      method: req.method,
+      path: req.url,
+      headers: req.headers,
+      files
+    });
+  }
+  async handleResponse(res, response) {
+    for (const [key, { value, ...opts }] of Object.entries(response.cookies)) res = res.setCookie(key, value, opts);
+    await res.status(response.status).headers(response.headers).send(response.body);
+  }
+  registerRoute(method, path, cb) {
+    this.#app.register(async (inst) => {
+      inst.route({ url: path, method, handler: cb });
+    });
+  }
+  registerErrorHandler(cb) {
+    this.#app.setErrorHandler(cb);
+  }
+  registerNotFoundHandler(cb) {
+    this.#app.setNotFoundHandler(cb);
+  }
+  async startServer(port) {
+    await this.#app.ready();
+    await this.#app.listen({ port, host: "0.0.0.0" });
+    Instance.on("close", this.#app.close);
+    return true;
+  }
+};
 function excludeBufferKeys(body) {
   if (typeof body !== "object") return { body, files: {} };
   const entries = Object.entries(body ?? {});
@@ -118,4 +128,3 @@ function excludeBufferKeys(body) {
 export {
   FastifyServer
 };
-//# sourceMappingURL=fastify.mjs.map