bun-platform-kit 1.0.0

package/dist/adapters/index.d.ts

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

package/dist/adapters/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./BunAdapter"), exports);

package/dist/controllers/ReportFinanceController.js

@@ -0,0 +1 @@
+"use strict";

package/dist/decorators/Controller.d.ts

@@ -0,0 +1,2 @@
+import "reflect-metadata";
+export declare function Controller(basePath: string): (...args: any[]) => void;

package/dist/decorators/Controller.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = Controller;
+const MetadataKeys_1 = require("./MetadataKeys");
+const DecoratorGuards_1 = require("./DecoratorGuards");
+require("reflect-metadata");
+function Controller(basePath) {
+    return function (...args) {
+        (0, DecoratorGuards_1.assertLegacyDecorator)(args, "@Controller");
+        const target = args[0];
+        Reflect.defineMetadata(MetadataKeys_1.MetadataKeys.BASE_PATH, basePath, target);
+    };
+}

package/dist/decorators/DecoratorGuards.d.ts

@@ -0,0 +1 @@
+export declare function assertLegacyDecorator(args: any[], decoratorName: string): void;

package/dist/decorators/DecoratorGuards.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertLegacyDecorator = assertLegacyDecorator;
+function assertLegacyDecorator(args, decoratorName) {
+    const context = args[1];
+    if (args.length === 2 &&
+        context &&
+        typeof context === "object" &&
+        "kind" in context) {
+        throw new Error(`[bun-platform-kit] ${decoratorName} is not compatible with ` +
+            `standard TypeScript decorators. Enable "experimentalDecorators": true ` +
+            `in your tsconfig and ensure your files are included by that config.`);
+    }
+}

package/dist/decorators/Handlers.d.ts

@@ -0,0 +1,18 @@
+import "reflect-metadata";
+export declare enum Methods {
+    GET = "get",
+    POST = "post",
+    PUT = "put",
+    DELETE = "delete",
+    PATCH = "patch"
+}
+export interface IRouter {
+    method: Methods;
+    path: string;
+    handlerName: string | symbol;
+}
+export declare const Get: (path: string) => (...args: any[]) => void;
+export declare const Post: (path: string) => (...args: any[]) => void;
+export declare const Put: (path: string) => (...args: any[]) => void;
+export declare const Delete: (path: string) => (...args: any[]) => void;
+export declare const Patch: (path: string) => (...args: any[]) => void;

package/dist/decorators/Handlers.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Patch = exports.Delete = exports.Put = exports.Post = exports.Get = exports.Methods = void 0;
+const MetadataKeys_1 = require("./MetadataKeys");
+const DecoratorGuards_1 = require("./DecoratorGuards");
+require("reflect-metadata");
+var Methods;
+(function (Methods) {
+    Methods["GET"] = "get";
+    Methods["POST"] = "post";
+    Methods["PUT"] = "put";
+    Methods["DELETE"] = "delete";
+    Methods["PATCH"] = "patch";
+})(Methods || (exports.Methods = Methods = {}));
+function methodDecorator(method) {
+    return function (path) {
+        return function (...args) {
+            (0, DecoratorGuards_1.assertLegacyDecorator)(args, `@${method.toUpperCase()}`);
+            const target = args[0];
+            const key = args[1];
+            const routers = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.ROUTERS, target) || [];
+            routers.push({
+                method,
+                path,
+                handlerName: key,
+            });
+            Reflect.defineMetadata(MetadataKeys_1.MetadataKeys.ROUTERS, routers, target);
+        };
+    };
+}
+exports.Get = methodDecorator(Methods.GET);
+exports.Post = methodDecorator(Methods.POST);
+exports.Put = methodDecorator(Methods.PUT);
+exports.Delete = methodDecorator(Methods.DELETE);
+exports.Patch = methodDecorator(Methods.PATCH);

package/dist/decorators/MetadataKeys.d.ts

@@ -0,0 +1,6 @@
+export declare enum MetadataKeys {
+    BASE_PATH = "base_path",
+    ROUTERS = "routers",
+    MIDDLEWARE = "middleware",
+    PARAMETERS = "parameters"
+}

package/dist/decorators/MetadataKeys.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataKeys = void 0;
+var MetadataKeys;
+(function (MetadataKeys) {
+    MetadataKeys["BASE_PATH"] = "base_path";
+    MetadataKeys["ROUTERS"] = "routers";
+    MetadataKeys["MIDDLEWARE"] = "middleware";
+    MetadataKeys["PARAMETERS"] = "parameters";
+})(MetadataKeys || (exports.MetadataKeys = MetadataKeys = {}));

package/dist/decorators/Parameters.d.ts

@@ -0,0 +1,24 @@
+import "reflect-metadata";
+export declare enum ParameterType {
+    BODY = "body",
+    QUERY = "query",
+    PARAM = "param",
+    HEADERS = "headers",
+    REQUEST = "request",
+    RESPONSE = "response",
+    NEXT = "next",
+    FILE = "file"
+}
+export interface ParameterMetadata {
+    index: number;
+    type: ParameterType;
+    data?: string;
+}
+export declare const Body: (data?: string) => ParameterDecorator;
+export declare const Query: (data?: string) => ParameterDecorator;
+export declare const Param: (data?: string) => ParameterDecorator;
+export declare const Headers: (data?: string) => ParameterDecorator;
+export declare const Req: (data?: string) => ParameterDecorator;
+export declare const Res: (data?: string) => ParameterDecorator;
+export declare const Next: (data?: string) => ParameterDecorator;
+export declare const UploadedFile: (data?: string) => ParameterDecorator;

package/dist/decorators/Parameters.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadedFile = exports.Next = exports.Res = exports.Req = exports.Headers = exports.Param = exports.Query = exports.Body = exports.ParameterType = void 0;
+require("reflect-metadata");
+const MetadataKeys_1 = require("./MetadataKeys");
+var ParameterType;
+(function (ParameterType) {
+    ParameterType["BODY"] = "body";
+    ParameterType["QUERY"] = "query";
+    ParameterType["PARAM"] = "param";
+    ParameterType["HEADERS"] = "headers";
+    ParameterType["REQUEST"] = "request";
+    ParameterType["RESPONSE"] = "response";
+    ParameterType["NEXT"] = "next";
+    ParameterType["FILE"] = "file";
+})(ParameterType || (exports.ParameterType = ParameterType = {}));
+// Helper to register parameter metadata for a method
+function addParameterMetadata(target, propertyKey, metadata) {
+    const existingParameters = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.PARAMETERS, target, propertyKey) || [];
+    Reflect.defineMetadata(MetadataKeys_1.MetadataKeys.PARAMETERS, [...existingParameters, metadata].sort((a, b) => a.index - b.index), target, propertyKey);
+}
+function createParameterDecorator(type) {
+    return (data) => (target, propertyKey, parameterIndex) => {
+        if (propertyKey === undefined) {
+            throw new Error("Parameter decorators can only be used on methods");
+        }
+        addParameterMetadata(target, propertyKey, {
+            index: parameterIndex,
+            type,
+            data,
+        });
+    };
+}
+exports.Body = createParameterDecorator(ParameterType.BODY);
+exports.Query = createParameterDecorator(ParameterType.QUERY);
+exports.Param = createParameterDecorator(ParameterType.PARAM);
+exports.Headers = createParameterDecorator(ParameterType.HEADERS);
+exports.Req = createParameterDecorator(ParameterType.REQUEST);
+exports.Res = createParameterDecorator(ParameterType.RESPONSE);
+exports.Next = createParameterDecorator(ParameterType.NEXT);
+exports.UploadedFile = createParameterDecorator(ParameterType.FILE);

package/dist/decorators/Use.d.ts

@@ -0,0 +1,3 @@
+import { ServerHandler } from "../abstract";
+import "reflect-metadata";
+export declare function Use(middleware: ServerHandler | ServerHandler[]): (...args: any[]) => void;

package/dist/decorators/Use.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Use = Use;
+const MetadataKeys_1 = require("./MetadataKeys");
+const DecoratorGuards_1 = require("./DecoratorGuards");
+require("reflect-metadata");
+function Use(middleware) {
+    return function (...args) {
+        (0, DecoratorGuards_1.assertLegacyDecorator)(args, "@Use");
+        const target = args[0];
+        const key = args[1];
+        const newMiddlewares = Array.isArray(middleware)
+            ? middleware
+            : [middleware];
+        if (key) {
+            // Method decorator
+            const middlewares = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.MIDDLEWARE, target, key) || [];
+            Reflect.defineMetadata(MetadataKeys_1.MetadataKeys.MIDDLEWARE, [...middlewares, ...newMiddlewares], target, key);
+        }
+        else {
+            // Class decorator
+            const middlewares = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.MIDDLEWARE, target) || [];
+            Reflect.defineMetadata(MetadataKeys_1.MetadataKeys.MIDDLEWARE, [...middlewares, ...newMiddlewares], target);
+        }
+    };
+}

package/dist/decorators/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./Controller";
+export * from "./Handlers";
+export * from "./MetadataKeys";
+export * from "./Use";
+export * from "./Parameters";

package/dist/decorators/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Controller"), exports);
+__exportStar(require("./Handlers"), exports);
+__exportStar(require("./MetadataKeys"), exports);
+__exportStar(require("./Use"), exports);
+__exportStar(require("./Parameters"), exports);

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import "reflect-metadata";
+export { BunKitServer } from "./BunKitServer";
+export type { BunKitServerOptions } from "./BunKitServer";
+export { BunKitStandardServer } from "./BunKitStandardServer";
+export type { BunKitStandardServerOptions } from "./BunKitStandardServer";
+export * from "./adapters";
+export * from "./modules";
+export * from "./abstract";
+export * from "./decorators";
+export * from "./testing";

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BunKitStandardServer = exports.BunKitServer = void 0;
+require("reflect-metadata");
+var BunKitServer_1 = require("./BunKitServer");
+Object.defineProperty(exports, "BunKitServer", { enumerable: true, get: function () { return BunKitServer_1.BunKitServer; } });
+var BunKitStandardServer_1 = require("./BunKitStandardServer");
+Object.defineProperty(exports, "BunKitStandardServer", { enumerable: true, get: function () { return BunKitStandardServer_1.BunKitStandardServer; } });
+__exportStar(require("./adapters"), exports);
+__exportStar(require("./modules"), exports);
+__exportStar(require("./abstract"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./testing"), exports);

package/dist/modules/ControllersModule.d.ts

@@ -0,0 +1,11 @@
+import { BaseServerModule } from "../abstract";
+import { ServerApp, ServerContext } from "../abstract";
+import "reflect-metadata";
+export declare class ControllersModule extends BaseServerModule {
+    private controllers;
+    name: string;
+    priority: number;
+    constructor(controllers: Function[]);
+    getModuleName(): string;
+    init(app: ServerApp, context?: ServerContext): void;
+}

package/dist/modules/ControllersModule.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControllersModule = void 0;
+const abstract_1 = require("../abstract");
+const adapters_1 = require("../adapters");
+const MetadataKeys_1 = require("../decorators/MetadataKeys");
+const Parameters_1 = require("../decorators/Parameters");
+require("reflect-metadata");
+class ControllersModule extends abstract_1.BaseServerModule {
+    constructor(controllers) {
+        super();
+        this.controllers = controllers;
+        this.name = "Controllers";
+        this.priority = 10;
+    }
+    getModuleName() {
+        return this.name;
+    }
+    init(app, context) {
+        this.controllers.forEach((ControllerClass) => {
+            const basePath = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.BASE_PATH, ControllerClass);
+            const classMiddlewares = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.MIDDLEWARE, ControllerClass) || [];
+            const routers = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.ROUTERS, ControllerClass.prototype) || [];
+            if (!basePath) {
+                return;
+            }
+            const adapter = context?.adapter ?? new adapters_1.BunAdapter();
+            const router = adapter.createRouter();
+            // Create a single controller instance per controller class (singleton pattern)
+            const controllerInstance = new ControllerClass();
+            // Apply class-level middlewares
+            if (classMiddlewares.length > 0) {
+                router.use(classMiddlewares);
+            }
+            routers.forEach(({ method, path, handlerName }) => {
+                const routeHandler = ControllerClass.prototype[handlerName];
+                const routeMiddlewares = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.MIDDLEWARE, ControllerClass.prototype, handlerName) || [];
+                const parameterMetadata = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.PARAMETERS, ControllerClass.prototype, handlerName) || [];
+                const routerMethod = router[method]?.bind(router);
+                routerMethod(path, ...routeMiddlewares, async (req, res, next) => {
+                    if (parameterMetadata.length === 0) {
+                        try {
+                            const result = routeHandler.call(controllerInstance, req, res, next);
+                            if (result instanceof Promise) {
+                                await result;
+                            }
+                            return result;
+                        }
+                        catch (error) {
+                            return next(error);
+                        }
+                    }
+                    const maxIndex = Math.max(routeHandler.length - 1, ...parameterMetadata.map((param) => param.index));
+                    const args = new Array(Math.max(0, maxIndex + 1));
+                    parameterMetadata.forEach((param) => {
+                        switch (param.type) {
+                            case Parameters_1.ParameterType.BODY:
+                                if (param.data) {
+                                    const body = req.body;
+                                    args[param.index] = body ? body[param.data] : undefined;
+                                }
+                                else {
+                                    args[param.index] = req.body;
+                                }
+                                break;
+                            case Parameters_1.ParameterType.PARAM:
+                                args[param.index] = param.data
+                                    ? req.params?.[param.data]
+                                    : req.params;
+                                break;
+                            case Parameters_1.ParameterType.QUERY:
+                                args[param.index] =
+                                    param.data && req.query ? req.query[param.data] : req.query;
+                                break;
+                            case Parameters_1.ParameterType.HEADERS:
+                                if (param.data) {
+                                    const headerKey = param.data.toLowerCase();
+                                    args[param.index] = req.headers?.[headerKey];
+                                }
+                                else {
+                                    args[param.index] = req.headers;
+                                }
+                                break;
+                            case Parameters_1.ParameterType.FILE: {
+                                const files = req.files;
+                                if (!files) {
+                                    args[param.index] = undefined;
+                                    break;
+                                }
+                                if (param.data) {
+                                    args[param.index] = files[param.data];
+                                }
+                                else {
+                                    args[param.index] = files;
+                                }
+                                break;
+                            }
+                            case Parameters_1.ParameterType.REQUEST:
+                                args[param.index] = req;
+                                break;
+                            case Parameters_1.ParameterType.RESPONSE:
+                                args[param.index] = res;
+                                break;
+                            case Parameters_1.ParameterType.NEXT:
+                                args[param.index] = next;
+                                break;
+                            default:
+                                args[param.index] = undefined;
+                                break;
+                        }
+                    });
+                    // Fallbacks for common handler arguments when not explicitly decorated
+                    if (args[0] === undefined) {
+                        args[0] = req;
+                    }
+                    if (args[1] === undefined) {
+                        args[1] = res;
+                    }
+                    if (args[2] === undefined) {
+                        args[2] = next;
+                    }
+                    try {
+                        const result = routeHandler.apply(controllerInstance, args);
+                        if (result instanceof Promise) {
+                            await result;
+                        }
+                        return result;
+                    }
+                    catch (error) {
+                        return next(error);
+                    }
+                });
+            });
+            app.use(basePath, router);
+        });
+    }
+}
+exports.ControllersModule = ControllersModule;

package/dist/modules/CorsModule.d.ts

@@ -0,0 +1,12 @@
+import { BaseServerModule } from "../abstract";
+import { ServerApp, ServerContext } from "../abstract";
+import type { CorsOptions } from "cors";
+export declare class CorsModule extends BaseServerModule {
+    name: string;
+    priority: number;
+    private corsOptions;
+    private static defaultCorsOptions;
+    constructor(corsOptions?: CorsOptions);
+    getModuleName(): string;
+    init(app: ServerApp, context?: ServerContext): void;
+}

package/dist/modules/CorsModule.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CorsModule = void 0;
+const abstract_1 = require("../abstract");
+class CorsModule extends abstract_1.BaseServerModule {
+    constructor(corsOptions) {
+        super();
+        this.name = "Cors";
+        this.priority = -90;
+        this.corsOptions = {
+            ...CorsModule.defaultCorsOptions,
+            ...(corsOptions || {}),
+        };
+    }
+    getModuleName() {
+        return this.name;
+    }
+    init(app, context) {
+        app.use(createCorsMiddleware(this.corsOptions));
+    }
+}
+exports.CorsModule = CorsModule;
+CorsModule.defaultCorsOptions = {
+    origin: "*",
+    allowedHeaders: ["content-type"],
+    methods: ["GET", "HEAD", "PUT", "PATCH", "POST", "DELETE", "OPTIONS"],
+    preflightContinue: false,
+    optionsSuccessStatus: 204,
+};
+const createCorsMiddleware = (options) => {
+    return (req, res, next) => {
+        const originHeader = String(req.headers?.origin || "");
+        const allowOrigin = resolveOrigin(options.origin, originHeader);
+        if (allowOrigin) {
+            res.set("access-control-allow-origin", allowOrigin);
+        }
+        if (options.credentials) {
+            res.set("access-control-allow-credentials", "true");
+        }
+        if (options.methods) {
+            res.set("access-control-allow-methods", Array.isArray(options.methods)
+                ? options.methods.join(",")
+                : options.methods);
+        }
+        if (options.allowedHeaders) {
+            res.set("access-control-allow-headers", Array.isArray(options.allowedHeaders)
+                ? options.allowedHeaders.join(",")
+                : options.allowedHeaders);
+        }
+        if (options.maxAge !== undefined) {
+            res.set("access-control-max-age", String(options.maxAge));
+        }
+        if (req.method === "OPTIONS") {
+            res.status(204).end();
+            return;
+        }
+        next();
+    };
+};
+const resolveOrigin = (originOption, requestOrigin) => {
+    if (!originOption || originOption === "*") {
+        return "*";
+    }
+    if (originOption === true) {
+        return requestOrigin || "*";
+    }
+    if (typeof originOption === "string") {
+        return originOption;
+    }
+    if (Array.isArray(originOption)) {
+        return originOption.includes(requestOrigin) ? requestOrigin : undefined;
+    }
+    if (typeof originOption === "function") {
+        let resolved;
+        originOption(requestOrigin, (err, value) => {
+            if (err) {
+                return;
+            }
+            if (value === true) {
+                resolved = requestOrigin || "*";
+            }
+            else if (typeof value === "string") {
+                resolved = value;
+            }
+        });
+        return resolved;
+    }
+    return undefined;
+};

package/dist/modules/FileUploadModule.d.ts

@@ -0,0 +1,21 @@
+import { BaseServerModule } from "../abstract";
+import { BunMultipartFile, ServerApp, ServerContext } from "../abstract";
+export type FileUploadOptions = {
+    maxBodyBytes?: number;
+    maxFileBytes?: number;
+    maxFiles?: number;
+    maxFields?: number;
+    maxFieldBytes?: number;
+    maxFieldsBytes?: number;
+    allowedMimeTypes?: string[];
+    allowedFileSignatures?: Array<"png" | "jpg" | "jpeg" | "pdf" | "csv">;
+    validateFile?: (file: BunMultipartFile) => boolean | Promise<boolean>;
+};
+export declare class FileUploadModule extends BaseServerModule {
+    name: string;
+    priority: number;
+    private fileUploadOptions;
+    constructor(fileUploadOptions?: FileUploadOptions);
+    getModuleName(): string;
+    init(app: ServerApp, context?: ServerContext): void;
+}

package/dist/modules/FileUploadModule.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileUploadModule = void 0;
+const abstract_1 = require("../abstract");
+class FileUploadModule extends abstract_1.BaseServerModule {
+    constructor(fileUploadOptions) {
+        super();
+        this.name = "FileUpload";
+        this.priority = -60;
+        this.fileUploadOptions = fileUploadOptions ?? {};
+    }
+    getModuleName() {
+        return this.name;
+    }
+    init(app, context) {
+        app.set?.("fileUploadEnabled", true);
+        app.set?.("multipart", this.fileUploadOptions);
+    }
+}
+exports.FileUploadModule = FileUploadModule;

package/dist/modules/RateLimitModule.d.ts

@@ -0,0 +1,18 @@
+import { BaseServerModule } from "../abstract";
+import { ServerApp, ServerContext } from "../abstract";
+export type RateLimitOptions = {
+    windowMs?: number;
+    limit?: number;
+    max?: number;
+    standardHeaders?: boolean;
+    legacyHeaders?: boolean;
+    message?: string | Record<string, unknown>;
+};
+export declare class RateLimitModule extends BaseServerModule {
+    name: string;
+    priority: number;
+    private limiterOptions;
+    constructor(limiterOptions?: Partial<RateLimitOptions>);
+    getModuleName(): string;
+    init(app: ServerApp, context?: ServerContext): void;
+}