equipped 5.2.9 → 5.3.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,196 @@
+import { B as BaseRequestAuthMethod, S as Server, R as RawResponder } from '../../../base-DVr0fHil.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 express from 'express';
+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 createRawResponder(req: express.Request, res: express.Response): RawResponder;
+    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,176 @@
+import {
+  Instance,
+  Request,
+  Server,
+  StatusCodes,
+  configurable,
+  getMediaDuration,
+  serverConfigPipe
+} from "../../../chunk-YTY3EFNB.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);
+    }
+  }
+  createRawResponder(req, res) {
+    return this.createNodeRawResponder({ request: req, response: 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);
+      }
+    });
+  }
+};
+if (void 0) {
+  let ensureTestInstance = function() {
+    const instance = Instance.maybeGet() ?? Instance.create({ app: { name: "equipped-test" }, log: { level: "silent" } });
+    if (!testInstanceState.__equippedTestInstanceAliased) {
+      instance.alias("equipped-test");
+      testInstanceState.__equippedTestInstanceAliased = true;
+    }
+  }, createExpressResponse = function() {
+    return {
+      statusCode: 200,
+      headersSent: false,
+      writableEnded: false,
+      setHeader: vi.fn(),
+      end(chunk) {
+        void chunk;
+        this.headersSent = true;
+        this.writableEnded = true;
+      }
+    };
+  };
+  ensureTestInstance2 = ensureTestInstance, createExpressResponse2 = createExpressResponse;
+  const { describe, expect, test, vi } = void 0;
+  const testInstanceState = globalThis;
+  class TestExpressServer extends ExpressServer {
+    exposeRawResponder(req, res) {
+      return this.createRawResponder(req, res);
+    }
+  }
+  describe("ExpressServer raw responder", () => {
+    test("passes the Express request and response to the raw Node handler", async () => {
+      ensureTestInstance();
+      const server = TestExpressServer.create({ port: 0, requests: { log: false } });
+      const req = { marker: "request" };
+      const res = createExpressResponse();
+      let received = null;
+      await server.exposeRawResponder(
+        req,
+        res
+      )(async (request, response) => {
+        received = { request, response };
+        response.end("ok");
+      });
+      expect(received).toEqual({ request: req, response: res });
+    });
+  });
+}
+var ensureTestInstance2;
+var createExpressResponse2;
+export {
+  ExpressServer
+};

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

@@ -0,0 +1,221 @@
+import { B as BaseRequestAuthMethod, S as Server, R as RawResponder } from '../../../base-DVr0fHil.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 { FastifyRequest, FastifyReply } from 'fastify';
+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 createRawResponder(req: FastifyRequest, res: FastifyReply): RawResponder;
+    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 };