@hazeljs/core 0.2.0-alpha.1

package/dist/pipes/pipe.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultValuePipe = exports.ParseBoolPipe = exports.ParseFloatPipe = exports.ParseIntPipe = exports.ValidationError = void 0;
+const logger_1 = __importDefault(require("../logger"));
+class ValidationError extends Error {
+    constructor(message, errors) {
+        super(message);
+        this.errors = errors;
+        this.name = 'ValidationError';
+    }
+    toJSON() {
+        return {
+            message: this.message,
+            errors: this.errors.map((error) => ({
+                field: error.property,
+                messages: Object.values(error.constraints),
+                value: error.value,
+            })),
+        };
+    }
+}
+exports.ValidationError = ValidationError;
+class ParseIntPipe {
+    transform(value, context) {
+        logger_1.default.debug(`ParseIntPipe received value: ${value}`);
+        if (!value) {
+            throw new ValidationError('Value is required', [
+                {
+                    value,
+                    property: context.params?.id ? 'id' : 'value',
+                    constraints: { isNotEmpty: 'value must not be empty' },
+                },
+            ]);
+        }
+        const parsed = parseInt(value, 10);
+        logger_1.default.debug(`ParseIntPipe parsed value: ${parsed}`);
+        if (isNaN(parsed)) {
+            throw new ValidationError('Invalid integer value', [
+                {
+                    value,
+                    property: context.params?.id ? 'id' : 'value',
+                    constraints: { isInt: 'value must be an integer' },
+                },
+            ]);
+        }
+        return parsed;
+    }
+}
+exports.ParseIntPipe = ParseIntPipe;
+class ParseFloatPipe {
+    transform(value, context) {
+        logger_1.default.debug('Parsing float:', value);
+        const parsed = parseFloat(value);
+        if (isNaN(parsed)) {
+            throw new ValidationError('Invalid float value', [
+                {
+                    value,
+                    property: context.params?.id ? 'id' : 'value',
+                    constraints: { isFloat: 'value must be a float' },
+                },
+            ]);
+        }
+        return parsed;
+    }
+}
+exports.ParseFloatPipe = ParseFloatPipe;
+class ParseBoolPipe {
+    transform(value, context) {
+        logger_1.default.debug('Parsing boolean:', value);
+        if (value === 'true')
+            return true;
+        if (value === 'false')
+            return false;
+        throw new ValidationError('Invalid boolean value', [
+            {
+                value,
+                property: context.params?.id ? 'id' : 'value',
+                constraints: { isBoolean: 'value must be a boolean' },
+            },
+        ]);
+    }
+}
+exports.ParseBoolPipe = ParseBoolPipe;
+class DefaultValuePipe {
+    constructor(defaultValue) {
+        this.defaultValue = defaultValue;
+    }
+    transform(value) {
+        logger_1.default.debug('Applying default value:', { value, defaultValue: this.defaultValue });
+        return value === undefined ? this.defaultValue : value;
+    }
+}
+exports.DefaultValuePipe = DefaultValuePipe;

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

@@ -0,0 +1,6 @@
+import { PipeTransform } from './pipe';
+import { RequestContext } from '../request-context';
+export declare class ValidationPipe implements PipeTransform {
+    transform(value: unknown, context: RequestContext): Promise<unknown>;
+}
+//# sourceMappingURL=validation.pipe.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation.pipe.d.ts","sourceRoot":"","sources":["../../src/pipes/validation.pipe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAmB,MAAM,QAAQ,CAAC;AAIxD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAMpD,qBAAa,cAAe,YAAW,aAAa;IAC5C,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC;CAkD3E"}

package/dist/pipes/validation.pipe.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationPipe = void 0;
+const pipe_1 = require("./pipe");
+const logger_1 = __importDefault(require("../logger"));
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+function isConstructor(f) {
+    return typeof f === 'function';
+}
+class ValidationPipe {
+    async transform(value, context) {
+        logger_1.default.debug('ValidationPipe.transform - Input value:', value);
+        logger_1.default.debug('ValidationPipe.transform - Context:', context);
+        // Get DTO type from context
+        const dtoType = context.dtoType;
+        logger_1.default.debug('ValidationPipe.transform - DTO type:', dtoType?.name);
+        if (!isConstructor(dtoType)) {
+            logger_1.default.debug('ValidationPipe.transform - No valid DTO type provided, returning value as is');
+            return value;
+        }
+        try {
+            // Ensure value is an object before transformation
+            if (typeof value !== 'object' || value === null) {
+                throw new pipe_1.ValidationError('Invalid input: expected an object', [
+                    {
+                        property: 'body',
+                        constraints: { isObject: 'Input must be an object' },
+                        value,
+                    },
+                ]);
+            }
+            // Transform plain object to class instance
+            const instance = (0, class_transformer_1.plainToClass)(dtoType, value);
+            logger_1.default.debug('ValidationPipe.transform - Transformed instance:', instance);
+            // Validate instance
+            const errors = await (0, class_validator_1.validate)(instance);
+            if (errors.length > 0) {
+                logger_1.default.error('ValidationPipe.transform - Validation failed:', errors);
+                const formattedErrors = errors.map((error) => ({
+                    property: error.property,
+                    constraints: error.constraints || {},
+                    value: error.value,
+                }));
+                const validationError = new pipe_1.ValidationError('Validation failed', formattedErrors);
+                logger_1.default.error('ValidationPipe.transform - Throwing validation error:', validationError);
+                throw validationError;
+            }
+            logger_1.default.debug('ValidationPipe.transform - Validation successful');
+            return instance;
+        }
+        catch (error) {
+            logger_1.default.error('ValidationPipe.transform - Error during transformation:', error);
+            throw error;
+        }
+    }
+}
+exports.ValidationPipe = ValidationPipe;

package/dist/request-context.d.ts

@@ -0,0 +1,22 @@
+import { Type } from './types';
+export interface RequestContext {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    body: unknown;
+    dtoType?: Type<unknown>;
+    user?: {
+        id: string | number;
+        username?: string;
+        role: string;
+        [key: string]: unknown;
+    };
+    retryOptions?: {
+        count: number;
+        delay?: number;
+        retryIf?: (err: Error) => boolean;
+    };
+}
+//# sourceMappingURL=request-context.d.ts.map

package/dist/request-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-context.d.ts","sourceRoot":"","sources":["../src/request-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAE/B,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACxB,IAAI,CAAC,EAAE;QACL,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,IAAI,EAAE,MAAM,CAAC;QACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,CAAC;IACF,YAAY,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,OAAO,CAAA;KAAE,CAAC;CACrF"}

package/dist/request-context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/request-parser.d.ts

@@ -0,0 +1,7 @@
+import { RequestContext, Request } from './types';
+export declare class RequestParser {
+    static parseRequest(req: Request): Promise<RequestContext>;
+    private static normalizeHeaders;
+    private static parseQueryString;
+}
+//# sourceMappingURL=request-parser.d.ts.map

package/dist/request-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-parser.d.ts","sourceRoot":"","sources":["../src/request-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAIlD,qBAAa,aAAa;WACX,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,CAAC;IAqChE,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAW/B,OAAO,CAAC,MAAM,CAAC,gBAAgB;CAQhC"}

package/dist/request-parser.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestParser = void 0;
+const logger_1 = __importDefault(require("./logger"));
+class RequestParser {
+    static async parseRequest(req) {
+        try {
+            const { method, url, headers } = req;
+            const context = {
+                method: method || 'GET',
+                url: url || '/',
+                headers: this.normalizeHeaders(headers),
+                params: { ...req.params },
+                query: {},
+                body: req.body || {},
+            };
+            // Parse query parameters
+            if (url) {
+                const queryString = url.split('?')[1];
+                if (queryString) {
+                    context.query = this.parseQueryString(queryString);
+                }
+            }
+            logger_1.default.debug('Parsed request context:', context);
+            return context;
+        }
+        catch (error) {
+            const err = error;
+            logger_1.default.error(`[${req.method}] ${req.url} - Request parsing error: ${err.message} (status: ${err.status || 400})`);
+            if (process.env.NODE_ENV === 'development' && err.stack) {
+                logger_1.default.debug(err.stack);
+            }
+            if (!err.status) {
+                err.status = 500;
+            }
+            throw error;
+        }
+    }
+    static normalizeHeaders(headers) {
+        const normalized = {};
+        if (!headers)
+            return normalized;
+        for (const [key, value] of Object.entries(headers)) {
+            normalized[key.toLowerCase()] = Array.isArray(value) ? value.join(', ') : value || '';
+        }
+        return normalized;
+    }
+    static parseQueryString(queryString) {
+        const params = {};
+        const searchParams = new URLSearchParams(queryString);
+        for (const [key, value] of searchParams.entries()) {
+            params[key] = value;
+        }
+        return params;
+    }
+}
+exports.RequestParser = RequestParser;

package/dist/router.d.ts

@@ -0,0 +1,33 @@
+import { Type } from './types';
+import { RequestContext, Request, Response } from './types';
+import { Container } from './container';
+import 'reflect-metadata';
+interface RouteMatch {
+    handler: RouteHandler;
+    context: RequestContext;
+}
+type RouteHandler = (req: Request, res: Response, context?: RequestContext) => void;
+export declare class Router {
+    private container;
+    private routes;
+    private routesByMethod;
+    private middlewareHandler;
+    constructor(container: Container);
+    registerController(controller: Type<unknown>): void;
+    private applyPipes;
+    private applyInterceptors;
+    private createRouteHandler;
+    private extractParams;
+    private matchPath;
+    private createRoutePattern;
+    private normalizePath;
+    match(method: string, url: string, context: RequestContext): Promise<RouteMatch | null>;
+    get(path: string, handlers: RouteHandler[]): void;
+    post(path: string, handlers: RouteHandler[]): void;
+    put(path: string, handlers: RouteHandler[]): void;
+    delete(path: string, handlers: RouteHandler[]): void;
+    private addRoute;
+    handleRequest(req: Request, res: Response): Promise<void>;
+}
+export {};
+//# sourceMappingURL=router.d.ts.map

package/dist/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAMxC,OAAO,kBAAkB,CAAC;AAc1B,UAAU,UAAU;IAClB,OAAO,EAAE,YAAY,CAAC;IACtB,OAAO,EAAE,cAAc,CAAC;CACzB;AAED,KAAK,YAAY,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;AAEpF,qBAAa,MAAM;IAKL,OAAO,CAAC,SAAS;IAJ7B,OAAO,CAAC,MAAM,CAA0C;IACxD,OAAO,CAAC,cAAc,CAAuD;IAC7E,OAAO,CAAC,iBAAiB,CAAoB;gBAEzB,SAAS,EAAE,SAAS;IAUxC,kBAAkB,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI;YA4DrC,UAAU;YAsBV,iBAAiB;IAe/B,OAAO,CAAC,kBAAkB;IAgT1B,OAAO,CAAC,aAAa;IAiBrB,OAAO,CAAC,SAAS;IAiBjB,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,aAAa;IAOf,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IA0C7F,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIjD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIlD,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIjD,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIpD,OAAO,CAAC,QAAQ;IAKV,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;CAkChE"}