@hazeljs/core 0.2.0-alpha.1

package/dist/middleware/rate-limit.middleware.d.ts

@@ -0,0 +1,73 @@
+import { Request, Response } from '../types';
+import { MiddlewareClass, NextFunction } from './global-middleware';
+/**
+ * Rate limit storage interface
+ */
+interface RateLimitStore {
+    get(key: string): Promise<number | null>;
+    set(key: string, value: number, ttl: number): Promise<void>;
+    increment(key: string, ttl: number): Promise<number>;
+    reset(key: string): Promise<void>;
+}
+/**
+ * Rate limit options
+ */
+export interface RateLimitOptions {
+    /**
+     * Maximum number of requests
+     */
+    max: number;
+    /**
+     * Time window in seconds
+     */
+    windowMs: number;
+    /**
+     * Custom key generator function
+     */
+    keyGenerator?: (req: Request) => string;
+    /**
+     * Custom store (default: in-memory)
+     */
+    store?: RateLimitStore;
+    /**
+     * Skip successful requests
+     */
+    skipSuccessfulRequests?: boolean;
+    /**
+     * Skip failed requests
+     */
+    skipFailedRequests?: boolean;
+    /**
+     * Custom error message
+     */
+    message?: string;
+    /**
+     * Custom error status code
+     */
+    statusCode?: number;
+    /**
+     * Standard rate limit headers
+     */
+    standardHeaders?: boolean;
+    /**
+     * Legacy rate limit headers
+     */
+    legacyHeaders?: boolean;
+}
+/**
+ * Rate Limiting Middleware
+ * Prevents abuse by limiting the number of requests from a single IP
+ */
+export declare class RateLimitMiddleware implements MiddlewareClass {
+    private options;
+    private store;
+    private cleanupInterval;
+    constructor(options: RateLimitOptions);
+    use(req: Request, res: Response, next: NextFunction): Promise<void>;
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+}
+export {};
+//# sourceMappingURL=rate-limit.middleware.d.ts.map

package/dist/middleware/rate-limit.middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.middleware.d.ts","sourceRoot":"","sources":["../../src/middleware/rate-limit.middleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAIpE;;GAEG;AACH,UAAU,cAAc;IACtB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACzC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnC;AA0DD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IAEZ;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,MAAM,CAAC;IAExC;;OAEG;IACH,KAAK,CAAC,EAAE,cAAc,CAAC;IAEvB;;OAEG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAEjC;;OAEG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;GAGG;AACH,qBAAa,mBAAoB,YAAW,eAAe;IAI7C,OAAO,CAAC,OAAO;IAH3B,OAAO,CAAC,KAAK,CAAiB;IAC9B,OAAO,CAAC,eAAe,CAA+B;gBAElC,OAAO,EAAE,gBAAgB;IA2BvC,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAkCzE;;OAEG;IACH,OAAO,IAAI,IAAI;CAMhB"}

package/dist/middleware/rate-limit.middleware.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitMiddleware = void 0;
+const http_error_1 = require("../errors/http.error");
+const logger_1 = __importDefault(require("../logger"));
+/**
+ * In-memory rate limit store
+ */
+class MemoryStore {
+    constructor() {
+        this.store = new Map();
+    }
+    async get(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return null;
+        if (Date.now() > entry.resetTime) {
+            this.store.delete(key);
+            return null;
+        }
+        return entry.count;
+    }
+    async set(key, value, ttl) {
+        this.store.set(key, {
+            count: value,
+            resetTime: Date.now() + ttl * 1000,
+        });
+    }
+    async increment(key, ttl) {
+        const entry = this.store.get(key);
+        const now = Date.now();
+        if (!entry || now > entry.resetTime) {
+            await this.set(key, 1, ttl);
+            return 1;
+        }
+        entry.count++;
+        this.store.set(key, entry);
+        return entry.count;
+    }
+    async reset(key) {
+        this.store.delete(key);
+    }
+    /**
+     * Clean up expired entries
+     */
+    cleanup() {
+        const now = Date.now();
+        for (const [key, entry] of this.store.entries()) {
+            if (now > entry.resetTime) {
+                this.store.delete(key);
+            }
+        }
+    }
+}
+/**
+ * Rate Limiting Middleware
+ * Prevents abuse by limiting the number of requests from a single IP
+ */
+class RateLimitMiddleware {
+    constructor(options) {
+        this.options = options;
+        this.cleanupInterval = null;
+        this.store = options.store || new MemoryStore();
+        // Set defaults
+        this.options = {
+            keyGenerator: (req) => {
+                const forwarded = req.headers?.['x-forwarded-for'];
+                const ip = forwarded
+                    ? (Array.isArray(forwarded) ? forwarded[0] : forwarded.split(',')[0].trim())
+                    : req.socket?.remoteAddress || 'unknown';
+                return ip;
+            },
+            message: 'Too many requests, please try again later.',
+            statusCode: 429,
+            standardHeaders: true,
+            legacyHeaders: true,
+            ...options,
+        };
+        // Cleanup expired entries every minute
+        if (this.store instanceof MemoryStore) {
+            this.cleanupInterval = setInterval(() => {
+                this.store.cleanup();
+            }, 60000);
+        }
+    }
+    async use(req, res, next) {
+        const key = this.options.keyGenerator(req);
+        const count = await this.store.increment(key, this.options.windowMs);
+        // Set rate limit headers
+        if (this.options.standardHeaders) {
+            res.setHeader('RateLimit-Limit', this.options.max.toString());
+            res.setHeader('RateLimit-Remaining', Math.max(0, this.options.max - count).toString());
+            res.setHeader('RateLimit-Reset', new Date(Date.now() + this.options.windowMs * 1000).toISOString());
+        }
+        if (this.options.legacyHeaders) {
+            res.setHeader('X-RateLimit-Limit', this.options.max.toString());
+            res.setHeader('X-RateLimit-Remaining', Math.max(0, this.options.max - count).toString());
+            res.setHeader('X-RateLimit-Reset', new Date(Date.now() + this.options.windowMs * 1000).toISOString());
+        }
+        // Check if limit exceeded
+        if (count > this.options.max) {
+            logger_1.default.warn(`Rate limit exceeded for ${key}: ${count}/${this.options.max}`);
+            throw new http_error_1.HttpError(this.options.statusCode, this.options.message);
+        }
+        await next();
+        // Handle skip options
+        // Note: Response statusCode is set via res.status() and checked via res.writeHead
+        // For now, we'll skip this check as Response interface doesn't expose statusCode directly
+        // In a real implementation, you'd track the status in a response interceptor
+    }
+    /**
+     * Cleanup resources
+     */
+    destroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+    }
+}
+exports.RateLimitMiddleware = RateLimitMiddleware;

package/dist/middleware/security-headers.middleware.d.ts

@@ -0,0 +1,76 @@
+import { Request, Response } from '../types';
+import { MiddlewareClass, NextFunction } from './global-middleware';
+/**
+ * Security headers configuration
+ */
+export interface SecurityHeadersOptions {
+    /**
+     * Enable X-Content-Type-Options header
+     * Prevents MIME type sniffing
+     */
+    noSniff?: boolean;
+    /**
+     * Enable X-Frame-Options header
+     * Prevents clickjacking attacks
+     */
+    frameOptions?: 'DENY' | 'SAMEORIGIN' | string;
+    /**
+     * Enable X-XSS-Protection header
+     * Enables browser XSS filter
+     */
+    xssProtection?: boolean;
+    /**
+     * Enable Strict-Transport-Security (HSTS) header
+     * Forces HTTPS connections
+     */
+    hsts?: {
+        maxAge?: number;
+        includeSubDomains?: boolean;
+        preload?: boolean;
+    };
+    /**
+     * Enable Content-Security-Policy header
+     * Controls resource loading
+     */
+    contentSecurityPolicy?: string | {
+        defaultSrc?: string[];
+        scriptSrc?: string[];
+        styleSrc?: string[];
+        imgSrc?: string[];
+        connectSrc?: string[];
+        fontSrc?: string[];
+        objectSrc?: string[];
+        mediaSrc?: string[];
+        frameSrc?: string[];
+        baseUri?: string[];
+        formAction?: string[];
+        frameAncestors?: string[];
+        upgradeInsecureRequests?: boolean;
+    };
+    /**
+     * Enable Referrer-Policy header
+     * Controls referrer information
+     */
+    referrerPolicy?: 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
+    /**
+     * Enable Permissions-Policy header
+     * Controls browser features
+     */
+    permissionsPolicy?: Record<string, string[]>;
+    /**
+     * Enable X-Powered-By removal
+     * Hides framework information
+     */
+    hidePoweredBy?: boolean;
+}
+/**
+ * Security Headers Middleware
+ * Adds security headers to HTTP responses
+ */
+export declare class SecurityHeadersMiddleware implements MiddlewareClass {
+    private options;
+    constructor(options?: SecurityHeadersOptions);
+    use(req: Request, res: Response, next: NextFunction): void;
+    private buildCSP;
+}
+//# sourceMappingURL=security-headers.middleware.d.ts.map

package/dist/middleware/security-headers.middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security-headers.middleware.d.ts","sourceRoot":"","sources":["../../src/middleware/security-headers.middleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEpE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,YAAY,GAAG,MAAM,CAAC;IAE9C;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,IAAI,CAAC,EAAE;QACL,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,CAAC;IAEF;;;OAGG;IACH,qBAAqB,CAAC,EAAE,MAAM,GAAG;QAC/B,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;QACtB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;QAClB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;QACtB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;QACtB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;QAC1B,uBAAuB,CAAC,EAAE,OAAO,CAAC;KACnC,CAAC;IAEF;;;OAGG;IACH,cAAc,CAAC,EAAE,aAAa,GAAG,4BAA4B,GAAG,QAAQ,GAAG,0BAA0B,GAAG,aAAa,GAAG,eAAe,GAAG,iCAAiC,GAAG,YAAY,CAAC;IAE3L;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAE7C;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;GAGG;AACH,qBAAa,yBAA0B,YAAW,eAAe;IACnD,OAAO,CAAC,OAAO;gBAAP,OAAO,GAAE,sBAA2B;IAgBxD,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI;IA+D1D,OAAO,CAAC,QAAQ;CAiDjB"}

package/dist/middleware/security-headers.middleware.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityHeadersMiddleware = void 0;
+/**
+ * Security Headers Middleware
+ * Adds security headers to HTTP responses
+ */
+class SecurityHeadersMiddleware {
+    constructor(options = {}) {
+        this.options = options;
+        // Set secure defaults
+        this.options = {
+            noSniff: true,
+            frameOptions: 'DENY',
+            xssProtection: true,
+            hsts: {
+                maxAge: 31536000, // 1 year
+                includeSubDomains: true,
+                preload: false,
+            },
+            hidePoweredBy: true,
+            ...options,
+        };
+    }
+    use(req, res, next) {
+        // Remove X-Powered-By header
+        if (this.options.hidePoweredBy) {
+            res.setHeader('X-Powered-By', '');
+        }
+        // X-Content-Type-Options
+        if (this.options.noSniff) {
+            res.setHeader('X-Content-Type-Options', 'nosniff');
+        }
+        // X-Frame-Options
+        if (this.options.frameOptions) {
+            res.setHeader('X-Frame-Options', this.options.frameOptions);
+        }
+        // X-XSS-Protection
+        if (this.options.xssProtection) {
+            res.setHeader('X-XSS-Protection', '1; mode=block');
+        }
+        // Strict-Transport-Security
+        if (this.options.hsts && (req.headers?.['x-forwarded-proto'] === 'https' || process.env.NODE_ENV === 'production')) {
+            const hstsValue = [
+                `max-age=${this.options.hsts.maxAge || 31536000}`,
+                this.options.hsts.includeSubDomains ? 'includeSubDomains' : '',
+                this.options.hsts.preload ? 'preload' : '',
+            ]
+                .filter(Boolean)
+                .join('; ');
+            res.setHeader('Strict-Transport-Security', hstsValue);
+        }
+        // Content-Security-Policy
+        if (this.options.contentSecurityPolicy) {
+            const csp = typeof this.options.contentSecurityPolicy === 'string'
+                ? this.options.contentSecurityPolicy
+                : this.buildCSP(this.options.contentSecurityPolicy);
+            res.setHeader('Content-Security-Policy', csp);
+        }
+        // Referrer-Policy
+        if (this.options.referrerPolicy) {
+            res.setHeader('Referrer-Policy', this.options.referrerPolicy);
+        }
+        // Permissions-Policy
+        if (this.options.permissionsPolicy) {
+            const permissions = Object.entries(this.options.permissionsPolicy)
+                .map(([feature, allowlist]) => {
+                const value = allowlist.length === 0 ? '()' : `(${allowlist.join(' ')})`;
+                return `${feature}=${value}`;
+            })
+                .join(', ');
+            res.setHeader('Permissions-Policy', permissions);
+        }
+        next();
+    }
+    buildCSP(policy) {
+        if (typeof policy === 'string') {
+            return policy;
+        }
+        const directives = [];
+        if (policy.defaultSrc) {
+            directives.push(`default-src ${policy.defaultSrc.join(' ')}`);
+        }
+        if (policy.scriptSrc) {
+            directives.push(`script-src ${policy.scriptSrc.join(' ')}`);
+        }
+        if (policy.styleSrc) {
+            directives.push(`style-src ${policy.styleSrc.join(' ')}`);
+        }
+        if (policy.imgSrc) {
+            directives.push(`img-src ${policy.imgSrc.join(' ')}`);
+        }
+        if (policy.connectSrc) {
+            directives.push(`connect-src ${policy.connectSrc.join(' ')}`);
+        }
+        if (policy.fontSrc) {
+            directives.push(`font-src ${policy.fontSrc.join(' ')}`);
+        }
+        if (policy.objectSrc) {
+            directives.push(`object-src ${policy.objectSrc.join(' ')}`);
+        }
+        if (policy.mediaSrc) {
+            directives.push(`media-src ${policy.mediaSrc.join(' ')}`);
+        }
+        if (policy.frameSrc) {
+            directives.push(`frame-src ${policy.frameSrc.join(' ')}`);
+        }
+        if (policy.baseUri) {
+            directives.push(`base-uri ${policy.baseUri.join(' ')}`);
+        }
+        if (policy.formAction) {
+            directives.push(`form-action ${policy.formAction.join(' ')}`);
+        }
+        if (policy.frameAncestors) {
+            directives.push(`frame-ancestors ${policy.frameAncestors.join(' ')}`);
+        }
+        if (policy.upgradeInsecureRequests) {
+            directives.push('upgrade-insecure-requests');
+        }
+        return directives.join('; ');
+    }
+}
+exports.SecurityHeadersMiddleware = SecurityHeadersMiddleware;

package/dist/middleware/timeout.middleware.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Request Timeout Middleware
+ * Prevents requests from hanging indefinitely
+ */
+import { Request, Response } from '../types';
+export interface TimeoutOptions {
+    timeout?: number;
+    message?: string;
+    onTimeout?: (req: Request) => void;
+}
+export declare class TimeoutMiddleware {
+    private timeout;
+    private message;
+    private onTimeout?;
+    constructor(options?: TimeoutOptions);
+    /**
+     * Create timeout handler for a request
+     */
+    handle(req: Request, res: Response, next: () => void): void;
+    /**
+     * Create middleware function
+     */
+    static create(options?: TimeoutOptions): (req: Request, res: Response, next: () => void) => void;
+}
+//# sourceMappingURL=timeout.middleware.d.ts.map

package/dist/middleware/timeout.middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.middleware.d.ts","sourceRoot":"","sources":["../../src/middleware/timeout.middleware.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAG7C,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;CACpC;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAC,CAAyB;gBAE/B,OAAO,GAAE,cAAmB;IAMxC;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI;IAmD3D;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,IAAI,KAAK,IAAI;CAIjG"}

package/dist/middleware/timeout.middleware.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Request Timeout Middleware
+ * Prevents requests from hanging indefinitely
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutMiddleware = void 0;
+const logger_1 = __importDefault(require("../logger"));
+class TimeoutMiddleware {
+    constructor(options = {}) {
+        this.timeout = options.timeout || 30000; // 30 seconds default
+        this.message = options.message || 'Request timeout';
+        this.onTimeout = options.onTimeout;
+    }
+    /**
+     * Create timeout handler for a request
+     */
+    handle(req, res, next) {
+        let timeoutId = null;
+        let timedOut = false;
+        // Set timeout
+        timeoutId = setTimeout(() => {
+            timedOut = true;
+            // Call custom timeout handler if provided
+            if (this.onTimeout) {
+                try {
+                    this.onTimeout(req);
+                }
+                catch (error) {
+                    logger_1.default.error('Error in timeout callback:', error);
+                }
+            }
+            // Log timeout
+            logger_1.default.warn('Request timeout:', {
+                method: req.method,
+                url: req.url,
+                timeout: this.timeout,
+            });
+            // Send timeout response
+            // Note: We can't check headersSent on our Response interface,
+            // but the status/json methods will handle this internally
+            res.status(408).json({
+                statusCode: 408,
+                message: this.message,
+                error: 'Request Timeout',
+            });
+        }, this.timeout);
+        // Clear timeout when response finishes
+        // Store original end method
+        const originalEnd = res.end.bind(res);
+        res.end = function () {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+            return originalEnd();
+        };
+        // Continue to next middleware
+        if (!timedOut) {
+            next();
+        }
+    }
+    /**
+     * Create middleware function
+     */
+    static create(options) {
+        const middleware = new TimeoutMiddleware(options);
+        return (req, res, next) => middleware.handle(req, res, next);
+    }
+}
+exports.TimeoutMiddleware = TimeoutMiddleware;

package/dist/middleware.d.ts

@@ -0,0 +1,13 @@
+import { Type } from './types';
+import { RequestContext } from './types';
+import { Container } from './container';
+export interface Middleware {
+    use(context: RequestContext, next: () => Promise<unknown>): Promise<unknown>;
+}
+export type MiddlewareFunction = (context: RequestContext, next: () => Promise<unknown>) => Promise<unknown>;
+export declare class MiddlewareHandler {
+    private container;
+    constructor(container: Container);
+    executeMiddlewareChain(middlewares: Type<Middleware>[], context: RequestContext, finalHandler: () => Promise<unknown>): Promise<unknown>;
+}
+//# sourceMappingURL=middleware.d.ts.map

package/dist/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../src/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,MAAM,WAAW,UAAU;IACzB,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC9E;AAED,MAAM,MAAM,kBAAkB,GAAG,CAC/B,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KACzB,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtB,qBAAa,iBAAiB;IAChB,OAAO,CAAC,SAAS;gBAAT,SAAS,EAAE,SAAS;IAElC,sBAAsB,CAC1B,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE,EAC/B,OAAO,EAAE,cAAc,EACvB,YAAY,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GACnC,OAAO,CAAC,OAAO,CAAC;CAwCpB"}

package/dist/middleware.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MiddlewareHandler = void 0;
+class MiddlewareHandler {
+    constructor(container) {
+        this.container = container;
+    }
+    async executeMiddlewareChain(middlewares, context, finalHandler) {
+        const next = async () => {
+            if (!middlewares || middlewares.length === 0) {
+                try {
+                    return await finalHandler();
+                }
+                catch (error) {
+                    const err = error;
+                    if (!err.status) {
+                        err.status = 500;
+                    }
+                    throw error;
+                }
+            }
+            const middleware = this.container.resolve(middlewares[0]);
+            const remainingMiddlewares = middlewares.slice(1);
+            try {
+                return await middleware.use(context, () => this.executeMiddlewareChain(remainingMiddlewares, context, finalHandler));
+            }
+            catch (error) {
+                const err = error;
+                if (!err.status) {
+                    err.status = 500;
+                }
+                throw error;
+            }
+        };
+        try {
+            return await next();
+        }
+        catch (error) {
+            const err = error;
+            if (!err.status) {
+                err.status = 500;
+            }
+            throw error;
+        }
+    }
+}
+exports.MiddlewareHandler = MiddlewareHandler;

package/dist/pipes/pipe.d.ts

@@ -0,0 +1,50 @@
+import { RequestContext } from '../request-context';
+export interface PipeTransform<T = unknown, R = unknown> {
+    transform(value: T, context: RequestContext): R | Promise<R>;
+}
+export interface PipeMetadata {
+    type: Type<PipeTransform>;
+    options?: unknown;
+}
+export interface ValidationPipeOptions {
+    whitelist?: boolean;
+    forbidNonWhitelisted?: boolean;
+    transform?: boolean;
+    validateCustomDecorators?: boolean;
+}
+export declare class ValidationError extends Error {
+    errors: Array<{
+        property: string;
+        constraints: Record<string, string>;
+        value?: unknown;
+    }>;
+    constructor(message: string, errors: Array<{
+        property: string;
+        constraints: Record<string, string>;
+        value?: unknown;
+    }>);
+    toJSON(): {
+        message: string;
+        errors: Array<{
+            field: string;
+            messages: string[];
+            value: unknown;
+        }>;
+    };
+}
+export declare class ParseIntPipe implements PipeTransform<string, number> {
+    transform(value: string, context: RequestContext): number;
+}
+export declare class ParseFloatPipe implements PipeTransform<string, number> {
+    transform(value: string, context: RequestContext): number;
+}
+export declare class ParseBoolPipe implements PipeTransform<string, boolean> {
+    transform(value: string, context: RequestContext): boolean;
+}
+export declare class DefaultValuePipe<T = unknown> implements PipeTransform<T | undefined, T> {
+    private defaultValue;
+    constructor(defaultValue: T);
+    transform(value: T | undefined): T;
+}
+export type Type<T = unknown> = new (...args: unknown[]) => T;
+//# sourceMappingURL=pipe.d.ts.map

package/dist/pipes/pipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe.d.ts","sourceRoot":"","sources":["../../src/pipes/pipe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGpD,MAAM,WAAW,aAAa,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO;IACrD,SAAS,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,cAAc,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAC9D;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IACpC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC;AAED,qBAAa,eAAgB,SAAQ,KAAK;IAG/B,MAAM,EAAE,KAAK,CAAC;QACnB,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACpC,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB,CAAC;gBALF,OAAO,EAAE,MAAM,EACR,MAAM,EAAE,KAAK,CAAC;QACnB,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACpC,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB,CAAC;IAMJ,MAAM,IAAI;QACR,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,KAAK,CAAC;YACZ,KAAK,EAAE,MAAM,CAAC;YACd,QAAQ,EAAE,MAAM,EAAE,CAAC;YACnB,KAAK,EAAE,OAAO,CAAC;SAChB,CAAC,CAAC;KACJ;CAUF;AAED,qBAAa,YAAa,YAAW,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC;IAChE,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM;CAwB1D;AAED,qBAAa,cAAe,YAAW,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC;IAClE,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM;CAc1D;AAED,qBAAa,aAAc,YAAW,aAAa,CAAC,MAAM,EAAE,OAAO,CAAC;IAClE,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO;CAY3D;AAED,qBAAa,gBAAgB,CAAC,CAAC,GAAG,OAAO,CAAE,YAAW,aAAa,CAAC,CAAC,GAAG,SAAS,EAAE,CAAC,CAAC;IACvE,OAAO,CAAC,YAAY;gBAAZ,YAAY,EAAE,CAAC;IAEnC,SAAS,CAAC,KAAK,EAAE,CAAC,GAAG,SAAS,GAAG,CAAC;CAInC;AAED,MAAM,MAAM,IAAI,CAAC,CAAC,GAAG,OAAO,IAAI,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC"}