@hazeljs/core 0.2.0-beta.1

package/dist/upload/file-upload.d.ts

@@ -0,0 +1,75 @@
+import { Request } from '../types';
+/**
+ * Uploaded file information
+ */
+export interface UploadedFile {
+    fieldname: string;
+    originalname: string;
+    encoding: string;
+    mimetype: string;
+    size: number;
+    destination: string;
+    filename: string;
+    path: string;
+    buffer?: Buffer;
+}
+/**
+ * File upload options
+ */
+export interface FileUploadOptions {
+    destination?: string;
+    filename?: (file: Partial<UploadedFile>) => string;
+    limits?: {
+        fileSize?: number;
+        files?: number;
+    };
+    fileFilter?: (file: Partial<UploadedFile>) => boolean;
+    storage?: 'disk' | 'memory';
+}
+/**
+ * File upload interceptor
+ */
+export declare class FileUploadInterceptor {
+    private options;
+    constructor(options?: FileUploadOptions);
+    /**
+     * Default filename generator
+     */
+    private defaultFilename;
+    /**
+     * Parse multipart form data
+     */
+    parseMultipart(req: Request): Promise<{
+        fields: Record<string, string>;
+        files: UploadedFile[];
+    }>;
+    /**
+     * Extract boundary from Content-Type header
+     */
+    private extractBoundary;
+    /**
+     * Parse buffer containing multipart data
+     */
+    private parseBuffer;
+    /**
+     * Split buffer by boundary
+     */
+    private splitBuffer;
+    /**
+     * Parse a single part
+     */
+    private parsePart;
+    /**
+     * Process uploaded file
+     */
+    private processFile;
+}
+/**
+ * File decorator for route parameters
+ */
+export declare function UploadedFileDecorator(fieldname?: string): ParameterDecorator;
+/**
+ * Files decorator for multiple files
+ */
+export declare function UploadedFilesDecorator(fieldname?: string): ParameterDecorator;
+//# sourceMappingURL=file-upload.d.ts.map

package/dist/upload/file-upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-upload.d.ts","sourceRoot":"","sources":["../../src/upload/file-upload.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAMnC;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,MAAM,CAAC;IACnD,MAAM,CAAC,EAAE;QACP,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,OAAO,CAAC;IACtD,OAAO,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;CAC7B;AAED;;GAEG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,OAAO,CAA8B;gBAEjC,OAAO,GAAE,iBAAsB;IAe3C;;OAEG;IACH,OAAO,CAAC,eAAe;IAOvB;;OAEG;IACG,cAAc,CAClB,GAAG,EAAE,OAAO,GACX,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,KAAK,EAAE,YAAY,EAAE,CAAA;KAAE,CAAC;IAkCrE;;OAEG;IACH,OAAO,CAAC,eAAe;IAKvB;;OAEG;YACW,WAAW;IA4CzB;;OAEG;IACH,OAAO,CAAC,WAAW;IAkBnB;;OAEG;IACH,OAAO,CAAC,SAAS;IAwBjB;;OAEG;YACW,WAAW;CAsC1B;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,kBAAkB,CAqB5E;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,kBAAkB,CAqB7E"}

package/dist/upload/file-upload.js

@@ -0,0 +1,261 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileUploadInterceptor = void 0;
+exports.UploadedFileDecorator = UploadedFileDecorator;
+exports.UploadedFilesDecorator = UploadedFilesDecorator;
+const logger_1 = __importDefault(require("../logger"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+/**
+ * File upload interceptor
+ */
+class FileUploadInterceptor {
+    constructor(options = {}) {
+        this.options = {
+            destination: options.destination || './uploads',
+            filename: options.filename || this.defaultFilename,
+            limits: options.limits || { fileSize: 10 * 1024 * 1024, files: 10 },
+            fileFilter: options.fileFilter || (() => true),
+            storage: options.storage || 'disk',
+        };
+        // Ensure destination directory exists
+        if (this.options.storage === 'disk' && !fs.existsSync(this.options.destination)) {
+            fs.mkdirSync(this.options.destination, { recursive: true });
+        }
+    }
+    /**
+     * Default filename generator
+     */
+    defaultFilename(file) {
+        const timestamp = Date.now();
+        const random = crypto.randomBytes(8).toString('hex');
+        const ext = path.extname(file.originalname || '');
+        return `${timestamp}-${random}${ext}`;
+    }
+    /**
+     * Parse multipart form data
+     */
+    async parseMultipart(req) {
+        const contentType = req.headers?.['content-type'] || '';
+        if (!contentType.includes('multipart/form-data')) {
+            throw new Error('Content-Type must be multipart/form-data');
+        }
+        const boundary = this.extractBoundary(contentType);
+        if (!boundary) {
+            throw new Error('Missing boundary in Content-Type');
+        }
+        const chunks = [];
+        const incomingMessage = req;
+        return new Promise((resolve, reject) => {
+            incomingMessage.on('data', (chunk) => {
+                chunks.push(chunk);
+            });
+            incomingMessage.on('end', async () => {
+                try {
+                    const buffer = Buffer.concat(chunks);
+                    const result = await this.parseBuffer(buffer, boundary);
+                    resolve(result);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+            incomingMessage.on('error', reject);
+        });
+    }
+    /**
+     * Extract boundary from Content-Type header
+     */
+    extractBoundary(contentType) {
+        const match = contentType.match(/boundary=([^;]+)/);
+        return match ? match[1].trim() : null;
+    }
+    /**
+     * Parse buffer containing multipart data
+     */
+    async parseBuffer(buffer, boundary) {
+        const fields = {};
+        const files = [];
+        const boundaryBuffer = Buffer.from(`--${boundary}`);
+        const parts = this.splitBuffer(buffer, boundaryBuffer);
+        for (const part of parts) {
+            if (part.length === 0)
+                continue;
+            const { headers, body } = this.parsePart(part);
+            const disposition = headers['content-disposition'];
+            if (!disposition)
+                continue;
+            const nameMatch = disposition.match(/name="([^"]+)"/);
+            const filenameMatch = disposition.match(/filename="([^"]+)"/);
+            if (filenameMatch) {
+                // It's a file
+                const file = await this.processFile({
+                    fieldname: nameMatch ? nameMatch[1] : 'file',
+                    originalname: filenameMatch[1],
+                    encoding: headers['content-transfer-encoding'] || '7bit',
+                    mimetype: headers['content-type'] || 'application/octet-stream',
+                    size: body.length,
+                    buffer: body,
+                });
+                if (file) {
+                    files.push(file);
+                }
+            }
+            else if (nameMatch) {
+                // It's a field
+                fields[nameMatch[1]] = body.toString('utf-8');
+            }
+        }
+        return { fields, files };
+    }
+    /**
+     * Split buffer by boundary
+     */
+    splitBuffer(buffer, boundary) {
+        const parts = [];
+        let start = 0;
+        while (start < buffer.length) {
+            const index = buffer.indexOf(boundary, start);
+            if (index === -1)
+                break;
+            if (start !== index) {
+                parts.push(buffer.slice(start, index));
+            }
+            start = index + boundary.length;
+        }
+        return parts;
+    }
+    /**
+     * Parse a single part
+     */
+    parsePart(part) {
+        const headerEnd = part.indexOf('\r\n\r\n');
+        if (headerEnd === -1) {
+            return { headers: {}, body: part };
+        }
+        const headerSection = part.slice(0, headerEnd).toString('utf-8');
+        const body = part.slice(headerEnd + 4);
+        const headers = {};
+        const lines = headerSection.split('\r\n');
+        for (const line of lines) {
+            const colonIndex = line.indexOf(':');
+            if (colonIndex !== -1) {
+                const key = line.slice(0, colonIndex).trim().toLowerCase();
+                const value = line.slice(colonIndex + 1).trim();
+                headers[key] = value;
+            }
+        }
+        return { headers, body };
+    }
+    /**
+     * Process uploaded file
+     */
+    async processFile(file) {
+        // Check file filter
+        if (!this.options.fileFilter(file)) {
+            logger_1.default.warn(`File rejected by filter: ${file.originalname}`);
+            return null;
+        }
+        // Check file size
+        if (file.size && file.size > (this.options.limits.fileSize || Infinity)) {
+            throw new Error(`File too large: ${file.originalname} (${file.size} bytes)`);
+        }
+        const filename = this.options.filename(file);
+        const destination = this.options.destination;
+        const filepath = path.join(destination, filename);
+        const uploadedFile = {
+            fieldname: file.fieldname,
+            originalname: file.originalname,
+            encoding: file.encoding,
+            mimetype: file.mimetype,
+            size: file.size,
+            destination,
+            filename,
+            path: filepath,
+        };
+        if (this.options.storage === 'disk') {
+            // Save to disk
+            await fs.promises.writeFile(filepath, file.buffer);
+            logger_1.default.info(`File saved: ${filepath}`);
+        }
+        else {
+            // Keep in memory
+            uploadedFile.buffer = file.buffer;
+        }
+        return uploadedFile;
+    }
+}
+exports.FileUploadInterceptor = FileUploadInterceptor;
+/**
+ * File decorator for route parameters
+ */
+function UploadedFileDecorator(fieldname) {
+    return (target, propertyKey, parameterIndex) => {
+        if (!propertyKey) {
+            throw new Error('UploadedFile decorator must be used on a method parameter');
+        }
+        const constructor = target
+            .constructor;
+        const injections = Reflect.getMetadata('hazel:inject', constructor, propertyKey) || [];
+        injections[parameterIndex] = {
+            type: 'file',
+            fieldname,
+        };
+        Reflect.defineMetadata('hazel:inject', injections, constructor, propertyKey);
+    };
+}
+/**
+ * Files decorator for multiple files
+ */
+function UploadedFilesDecorator(fieldname) {
+    return (target, propertyKey, parameterIndex) => {
+        if (!propertyKey) {
+            throw new Error('UploadedFiles decorator must be used on a method parameter');
+        }
+        const constructor = target
+            .constructor;
+        const injections = Reflect.getMetadata('hazel:inject', constructor, propertyKey) || [];
+        injections[parameterIndex] = {
+            type: 'files',
+            fieldname,
+        };
+        Reflect.defineMetadata('hazel:inject', injections, constructor, propertyKey);
+    };
+}

package/dist/utils/sanitize.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Input sanitization utilities
+ * Helps prevent XSS and injection attacks
+ */
+/**
+ * Sanitize HTML string
+ * Removes potentially dangerous HTML tags and attributes
+ */
+export declare function sanitizeHtml(input: string): string;
+/**
+ * Sanitize string input
+ * Removes control characters and normalizes whitespace
+ */
+export declare function sanitizeString(input: string): string;
+/**
+ * Sanitize URL
+ * Validates and sanitizes URL input
+ */
+export declare function sanitizeUrl(input: string): string;
+/**
+ * Sanitize email
+ * Basic email validation and sanitization
+ */
+export declare function sanitizeEmail(input: string): string;
+/**
+ * Sanitize SQL input (for raw queries)
+ * Escapes special characters (use parameterized queries instead!)
+ */
+export declare function sanitizeSql(input: string): string;
+/**
+ * Sanitize object recursively
+ * Applies sanitization to all string values in an object
+ */
+export declare function sanitizeObject<T extends Record<string, unknown>>(obj: T, options?: {
+    sanitizeHtml?: boolean;
+    sanitizeStrings?: boolean;
+    allowedKeys?: string[];
+    maxDepth?: number;
+}): T;
+/**
+ * Escape HTML entities
+ * Converts special characters to HTML entities
+ */
+export declare function escapeHtml(input: string): string;
+//# sourceMappingURL=sanitize.d.ts.map

package/dist/utils/sanitize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../src/utils/sanitize.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAYlD;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CASpD;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAejD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAanD;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAajD;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9D,GAAG,EAAE,CAAC,EACN,OAAO,GAAE;IACP,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACd,GACL,CAAC,CA2DH;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAchD"}

package/dist/utils/sanitize.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * Input sanitization utilities
+ * Helps prevent XSS and injection attacks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeHtml = sanitizeHtml;
+exports.sanitizeString = sanitizeString;
+exports.sanitizeUrl = sanitizeUrl;
+exports.sanitizeEmail = sanitizeEmail;
+exports.sanitizeSql = sanitizeSql;
+exports.sanitizeObject = sanitizeObject;
+exports.escapeHtml = escapeHtml;
+/**
+ * Sanitize HTML string
+ * Removes potentially dangerous HTML tags and attributes
+ */
+function sanitizeHtml(input) {
+    if (typeof input !== 'string') {
+        return String(input);
+    }
+    // Remove script tags and event handlers
+    return input
+        .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
+        .replace(/<iframe\b[^<]*(?:(?!<\/iframe>)<[^<]*)*<\/iframe>/gi, '')
+        .replace(/on\w+\s*=\s*["'][^"']*["']/gi, '')
+        .replace(/javascript:/gi, '')
+        .replace(/data:text\/html/gi, '');
+}
+/**
+ * Sanitize string input
+ * Removes control characters and normalizes whitespace
+ */
+function sanitizeString(input) {
+    if (typeof input !== 'string') {
+        return String(input);
+    }
+    return input
+        .replace(/[\x00-\x1F\x7F-\x9F]/g, '') // Remove control characters
+        .trim()
+        .replace(/\s+/g, ' '); // Normalize whitespace
+}
+/**
+ * Sanitize URL
+ * Validates and sanitizes URL input
+ */
+function sanitizeUrl(input) {
+    if (typeof input !== 'string') {
+        return '';
+    }
+    try {
+        const url = new URL(input);
+        // Only allow http and https protocols
+        if (!['http:', 'https:'].includes(url.protocol)) {
+            return '';
+        }
+        return url.toString();
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Sanitize email
+ * Basic email validation and sanitization
+ */
+function sanitizeEmail(input) {
+    if (typeof input !== 'string') {
+        return '';
+    }
+    const email = input.trim().toLowerCase();
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(email)) {
+        return '';
+    }
+    return email;
+}
+/**
+ * Sanitize SQL input (for raw queries)
+ * Escapes special characters (use parameterized queries instead!)
+ */
+function sanitizeSql(input) {
+    if (typeof input !== 'string') {
+        return '';
+    }
+    // WARNING: This is a basic sanitization
+    // Always use parameterized queries with Prisma instead!
+    return input
+        .replace(/'/g, "''")
+        .replace(/;/g, '')
+        .replace(/--/g, '')
+        .replace(/\/\*/g, '')
+        .replace(/\*\//g, '');
+}
+/**
+ * Sanitize object recursively
+ * Applies sanitization to all string values in an object
+ */
+function sanitizeObject(obj, options = {}) {
+    const { sanitizeHtml: sanitizeHtmlFields = false, sanitizeStrings: sanitizeStringFields = true, allowedKeys, maxDepth = 10, } = options;
+    if (maxDepth <= 0) {
+        return obj;
+    }
+    const sanitized = {};
+    for (const [key, value] of Object.entries(obj)) {
+        // Skip disallowed keys
+        if (allowedKeys && !allowedKeys.includes(key)) {
+            continue;
+        }
+        if (typeof value === 'string') {
+            if (sanitizeHtmlFields) {
+                sanitized[key] = sanitizeHtml(value);
+            }
+            else if (sanitizeStringFields) {
+                sanitized[key] = sanitizeString(value);
+            }
+            else {
+                sanitized[key] = value;
+            }
+        }
+        else if (Array.isArray(value)) {
+            sanitized[key] = value.map((item) => typeof item === 'object' && item !== null
+                ? sanitizeObject(item, {
+                    sanitizeHtml: sanitizeHtmlFields,
+                    sanitizeStrings: sanitizeStringFields,
+                    maxDepth: maxDepth - 1,
+                })
+                : typeof item === 'string'
+                    ? sanitizeHtmlFields
+                        ? sanitizeHtml(item)
+                        : sanitizeStringFields
+                            ? sanitizeString(item)
+                            : item
+                    : item);
+        }
+        else if (typeof value === 'object' && value !== null) {
+            sanitized[key] = sanitizeObject(value, {
+                sanitizeHtml: sanitizeHtmlFields,
+                sanitizeStrings: sanitizeStringFields,
+                maxDepth: maxDepth - 1,
+            });
+        }
+        else {
+            sanitized[key] = value;
+        }
+    }
+    return sanitized;
+}
+/**
+ * Escape HTML entities
+ * Converts special characters to HTML entities
+ */
+function escapeHtml(input) {
+    if (typeof input !== 'string') {
+        return String(input);
+    }
+    const map = {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&#039;',
+    };
+    return input.replace(/[&<>"']/g, (m) => map[m]);
+}

package/dist/validator.d.ts

@@ -0,0 +1,7 @@
+import { ValidationSchema, ValidationError } from './types';
+type ValidatableData = Record<string, unknown>;
+export declare class Validator {
+    static validate(data: ValidatableData, schema: ValidationSchema): ValidationError[];
+}
+export {};
+//# sourceMappingURL=validator.d.ts.map

package/dist/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../src/validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE5D,KAAK,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE/C,qBAAa,SAAS;IACpB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,eAAe,EAAE,MAAM,EAAE,gBAAgB,GAAG,eAAe,EAAE;CAsHpF"}

package/dist/validator.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = void 0;
+class Validator {
+    static validate(data, schema) {
+        const errors = [];
+        for (const [field, rules] of Object.entries(schema)) {
+            const value = data[field];
+            if (rules.required && (value === undefined || value === null || value === '')) {
+                errors.push({
+                    field,
+                    message: `${field} is required`,
+                });
+                continue;
+            }
+            if (value === undefined || value === null) {
+                continue;
+            }
+            switch (rules.type) {
+                case 'string':
+                    if (typeof value !== 'string') {
+                        errors.push({
+                            field,
+                            message: `${field} must be a string`,
+                        });
+                    }
+                    else {
+                        if (rules.min !== undefined && value.length < rules.min) {
+                            errors.push({
+                                field,
+                                message: `${field} must be at least ${rules.min} characters`,
+                            });
+                        }
+                        if (rules.max !== undefined && value.length > rules.max) {
+                            errors.push({
+                                field,
+                                message: `${field} must be at most ${rules.max} characters`,
+                            });
+                        }
+                        if (rules.pattern && !rules.pattern.test(value)) {
+                            errors.push({
+                                field,
+                                message: `${field} has invalid format`,
+                            });
+                        }
+                    }
+                    break;
+                case 'number':
+                    if (typeof value !== 'number') {
+                        errors.push({
+                            field,
+                            message: `${field} must be a number`,
+                        });
+                    }
+                    else {
+                        if (rules.min !== undefined && value < rules.min) {
+                            errors.push({
+                                field,
+                                message: `${field} must be at least ${rules.min}`,
+                            });
+                        }
+                        if (rules.max !== undefined && value > rules.max) {
+                            errors.push({
+                                field,
+                                message: `${field} must be at most ${rules.max}`,
+                            });
+                        }
+                    }
+                    break;
+                case 'boolean':
+                    if (typeof value !== 'boolean') {
+                        errors.push({
+                            field,
+                            message: `${field} must be a boolean`,
+                        });
+                    }
+                    break;
+                case 'object':
+                    if (typeof value !== 'object' || Array.isArray(value)) {
+                        errors.push({
+                            field,
+                            message: `${field} must be an object`,
+                        });
+                    }
+                    else if (rules.properties) {
+                        errors.push(...this.validate(value, rules.properties));
+                    }
+                    break;
+                case 'array':
+                    if (!Array.isArray(value)) {
+                        errors.push({
+                            field,
+                            message: `${field} must be an array`,
+                        });
+                    }
+                    else if (rules.items) {
+                        value.forEach((item, index) => {
+                            const itemSchema = {
+                                [`item_${index}`]: {
+                                    type: rules.items.type,
+                                    required: rules.items.required,
+                                    min: rules.items.min,
+                                    max: rules.items.max,
+                                    pattern: rules.items.pattern,
+                                    properties: rules.items.properties,
+                                    items: rules.items.items,
+                                },
+                            };
+                            const itemErrors = this.validate({ [`item_${index}`]: item }, itemSchema);
+                            errors.push(...itemErrors);
+                        });
+                    }
+                    break;
+            }
+        }
+        return errors;
+    }
+}
+exports.Validator = Validator;