lieko-express 0.0.8 → 0.0.10

package/lib/cors.js

@@ -0,0 +1,100 @@
+module.exports = function cors(userOptions = {}) {
+    const defaultOptions = {
+        enabled: true,
+        origin: "*",
+        strictOrigin: false,
+        allowPrivateNetwork: false,
+        methods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
+        headers: ["Content-Type", "Authorization"],
+        credentials: false,
+        maxAge: 86400,
+        exposedHeaders: [],
+        debug: false
+    };
+
+    const opts = { ...defaultOptions, ...userOptions, enabled: true };
+
+    const _matchOrigin = (origin, allowedOrigin) => {
+        if (!origin || !allowedOrigin) return false;
+        if (Array.isArray(allowedOrigin)) {
+            return allowedOrigin.some(o => _matchOrigin(origin, o));
+        }
+        if (allowedOrigin === "*") return true;
+        if (allowedOrigin.includes("*")) {
+            const regex = new RegExp("^" + allowedOrigin
+                .replace(/\./g, "\\.")
+                .replace(/\*/g, ".*") + "$");
+            return regex.test(origin);
+        }
+        return origin === allowedOrigin;
+    };
+
+    const _logDebug = (req, finalOpts) => {
+        if (!finalOpts.debug) return;
+        console.log("\n[CORS DEBUG]");
+        console.log("Request:", req.method, req.url);
+        console.log("Origin:", req.headers.origin || "none");
+        console.log("Applied CORS Policy:");
+        console.log("  - Access-Control-Allow-Origin:", finalOpts.origin);
+        console.log("  - Methods:", finalOpts.methods.join(", "));
+        console.log("  - Headers:", finalOpts.headers.join(", "));
+        if (finalOpts.credentials) console.log("  - Credentials: true");
+        if (finalOpts.exposedHeaders?.length) console.log("  - Exposed:", finalOpts.exposedHeaders.join(", "));
+        console.log("  - Max-Age:", finalOpts.maxAge);
+        if (req.method === "OPTIONS") console.log("Preflight handled → 204\n");
+    };
+
+    return function corsMiddleware(req, res, next) {
+        if (!opts.enabled) return next();
+
+        const requestOrigin = req.headers.origin || "";
+
+        let finalOrigin = "*";
+
+        if (opts.strictOrigin && requestOrigin) {
+            const allowed = _matchOrigin(requestOrigin, opts.origin);
+            if (!allowed) {
+                res.statusCode = 403;
+                return res.end(JSON.stringify({
+                    success: false,
+                    error: "Origin Forbidden",
+                    message: `Origin "${requestOrigin}" is not allowed`
+                }));
+            }
+        }
+
+        if (opts.origin === "*") {
+            finalOrigin = "*";
+        } else if (Array.isArray(opts.origin)) {
+            const match = opts.origin.find(o => _matchOrigin(requestOrigin, o));
+            finalOrigin = match || opts.origin[0];
+        } else {
+            finalOrigin = _matchOrigin(requestOrigin, opts.origin) ? requestOrigin : opts.origin;
+        }
+
+        _logDebug(req, { ...opts, origin: finalOrigin });
+
+        res.setHeader("Access-Control-Allow-Origin", finalOrigin);
+
+        if (opts.credentials) {
+            res.setHeader("Access-Control-Allow-Credentials", "true");
+        }
+
+        if (opts.exposedHeaders?.length) {
+            res.setHeader("Access-Control-Expose-Headers", opts.exposedHeaders.join(", "));
+        }
+
+        if (opts.allowPrivateNetwork && req.headers["access-control-request-private-network"] === "true") {
+            res.setHeader("Access-Control-Allow-Private-Network", "true");
+        }
+
+        if (req.method === "OPTIONS") {
+            res.setHeader("Access-Control-Allow-Methods", opts.methods.join(", "));
+            res.setHeader("Access-Control-Allow-Headers", opts.headers.join(", "));
+            res.setHeader("Access-Control-Max-Age", opts.maxAge);
+            res.statusCode = 204;
+            return res.end();
+        }
+        next();
+    };
+};

package/lib/schema.js

@@ -0,0 +1,418 @@
+class ValidationError extends Error {
+    constructor(errors) {
+        super('Validation failed');
+        this.name = 'ValidationError';
+        this.errors = errors;
+    }
+}
+
+class Schema {
+    constructor(rules) {
+        this.rules = rules;
+        this.fields = rules;
+    }
+
+    validate(data) {
+        const errors = [];
+        for (const [field, validators] of Object.entries(this.rules)) {
+            const value = data[field];
+            for (const validator of validators) {
+                const error = validator(value, field, data);
+                if (error) {
+                    errors.push(error);
+                    break;
+                }
+            }
+        }
+        if (errors.length > 0) throw new ValidationError(errors);
+        return true;
+    }
+}
+
+const validators = {
+    required: (message = 'Field is required') => {
+        return (value, field) => {
+            if (value === undefined || value === null || value === '') {
+                return { field, message, type: 'required' };
+            }
+            return null;
+        };
+    },
+
+    requiredTrue: (message = 'Field must be true') => {
+        return (value, field) => {
+            const normalized = value === true || value === 'true' || value === '1' || value === 1;
+            if (!normalized) {
+                return { field, message, type: 'requiredTrue' };
+            }
+            return null;
+        }
+    },
+
+    optional: () => {
+        return () => null;
+    },
+
+    string: (message = 'Field must be a string') => {
+        return (value, field) => {
+            if (value !== undefined && typeof value !== 'string') {
+                return { field, message, type: 'string' };
+            }
+            return null;
+        };
+    },
+
+    number: (message = 'Field must be a number') => {
+        return (value, field) => {
+            if (value !== undefined && typeof value !== 'number') {
+                return { field, message, type: 'number' };
+            }
+            return null;
+        };
+    },
+
+    boolean: (message = 'Field must be a boolean') => {
+        return (value, field) => {
+            if (value === undefined || value === null || value === '') return null;
+
+            const validTrue = ['true', true, 1, '1'];
+            const validFalse = ['false', false, 0, '0'];
+
+            const isValid = validTrue.includes(value) || validFalse.includes(value);
+
+            if (!isValid) {
+                return { field, message, type: 'boolean' };
+            }
+
+            return null;
+        };
+    },
+
+    integer: (message = 'Field must be an integer') => {
+        return (value, field) => {
+            if (value !== undefined && !Number.isInteger(value)) {
+                return { field, message, type: 'integer' };
+            }
+            return null;
+        };
+    },
+
+    positive: (message = 'Field must be positive') => {
+        return (value, field) => {
+            if (value !== undefined && value <= 0) {
+                return { field, message, type: 'positive' };
+            }
+            return null;
+        };
+    },
+
+    negative: (message = 'Field must be negative') => {
+        return (value, field) => {
+            if (value !== undefined && value >= 0) {
+                return { field, message, type: 'negative' };
+            }
+            return null;
+        };
+    },
+
+    email: (message = 'Invalid email format') => {
+        return (value, field) => {
+            if (value !== undefined && value !== null) {
+                const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                if (!emailRegex.test(value)) {
+                    return { field, message, type: 'email' };
+                }
+            }
+            return null;
+        };
+    },
+
+    min: (minValue, message) => {
+        return (value, field) => {
+            if (value !== undefined && value !== null) {
+                if (typeof value === 'string' && value.length < minValue) {
+                    return {
+                        field,
+                        message: message || `Field must be at least ${minValue} characters`,
+                        type: 'min'
+                    };
+                }
+                if (typeof value === 'number' && value < minValue) {
+                    return {
+                        field,
+                        message: message || `Field must be at least ${minValue}`,
+                        type: 'min'
+                    };
+                }
+            }
+            return null;
+        };
+    },
+
+    max: (maxValue, message) => {
+        return (value, field) => {
+            if (value !== undefined && value !== null) {
+                if (typeof value === 'string' && value.length > maxValue) {
+                    return {
+                        field,
+                        message: message || `Field must be at most ${maxValue} characters`,
+                        type: 'max'
+                    };
+                }
+                if (typeof value === 'number' && value > maxValue) {
+                    return {
+                        field,
+                        message: message || `Field must be at most ${maxValue}`,
+                        type: 'max'
+                    };
+                }
+            }
+            return null;
+        };
+    },
+
+    length: (n, message) => {
+        return (value, field) => {
+            if (typeof value === 'string' && value.length !== n) {
+                return {
+                    field,
+                    message: message || `Field must be exactly ${n} characters`,
+                    type: 'length'
+                };
+            }
+            return null;
+        };
+    },
+
+    minLength: (minLength, message) => {
+        return (value, field) => {
+            if (value !== undefined && value !== null && typeof value === 'string') {
+                if (value.length < minLength) {
+                    return {
+                        field,
+                        message: message || `Field must be at least ${minLength} characters`,
+                        type: 'minLength'
+                    };
+                }
+            }
+            return null;
+        };
+    },
+
+    maxLength: (maxLength, message) => {
+        return (value, field) => {
+            if (value !== undefined && value !== null && typeof value === 'string') {
+                if (value.length > maxLength) {
+                    return {
+                        field,
+                        message: message || `Field must be at most ${maxLength} characters`,
+                        type: 'maxLength'
+                    };
+                }
+            }
+            return null;
+        };
+    },
+
+    pattern: (regex, message = 'Invalid format') => {
+        return (value, field) => {
+            if (value !== undefined && value !== null && typeof value === 'string') {
+                if (!regex.test(value)) {
+                    return { field, message, type: 'pattern' };
+                }
+            }
+            return null;
+        };
+    },
+
+    oneOf: (allowedValues, message) => {
+        return (value, field) => {
+            if (value !== undefined && value !== null) {
+                if (!allowedValues.includes(value)) {
+                    return {
+                        field,
+                        message: message || `Field must be one of: ${allowedValues.join(', ')}`,
+                        type: 'oneOf'
+                    };
+                }
+            }
+            return null;
+        };
+    },
+
+    notOneOf: (values, message) => {
+        return (value, field) => {
+            if (values.includes(value)) {
+                return {
+                    field,
+                    message: message || `Field cannot be one of: ${values.join(', ')}`,
+                    type: 'notOneOf'
+                };
+            }
+            return null;
+        };
+    },
+
+    custom: (validatorFn, message = 'Validation failed') => {
+        return (value, field, data) => {
+            const isValid = validatorFn(value, data);
+            if (!isValid) {
+                return { field, message, type: 'custom' };
+            }
+            return null;
+        };
+    },
+
+    equal: (expectedValue, message) => {
+        return (value, field) => {
+            if (value !== expectedValue) {
+                return {
+                    field,
+                    message: message || `Field must be equal to ${expectedValue}`,
+                    type: 'equal'
+                };
+            }
+            return null;
+        };
+    },
+
+    mustBeTrue: (message = 'This field must be accepted') => {
+        return (value, field) => {
+            const normalized = value === true || value === 'true' || value === '1' || value === 1;
+            if (!normalized) {
+                return { field, message, type: 'mustBeTrue' };
+            }
+            return null;
+        };
+    },
+
+    mustBeFalse: (message = 'This field must be declined') => {
+        return (value, field) => {
+            const normalized = value === false || value === 'false' || value === '0' || value === 0;
+            if (!normalized) {
+                return { field, message, type: 'mustBeFalse' };
+            }
+            return null;
+        };
+    },
+
+    date: (message = 'Invalid date') => {
+        return (value, field) => {
+            if (!value) return null;
+            const date = new Date(value);
+            if (isNaN(date.getTime())) {
+                return { field, message, type: 'date' };
+            }
+            return null;
+        };
+    },
+
+    before: (limit, message) => {
+        return (value, field) => {
+            if (!value) return null;
+            const d1 = new Date(value);
+            const d2 = new Date(limit);
+            if (isNaN(d1) || d1 >= d2) {
+                return {
+                    field,
+                    message: message || `Date must be before ${limit}`,
+                    type: 'before'
+                };
+            }
+            return null;
+        };
+    },
+
+    after: (limit, message) => {
+        return (value, field) => {
+            if (!value) return null;
+            const d1 = new Date(value);
+            const d2 = new Date(limit);
+            if (isNaN(d1) || d1 <= d2) {
+                return {
+                    field,
+                    message: message || `Date must be after ${limit}`,
+                    type: 'after'
+                };
+            }
+            return null;
+        };
+    },
+
+    startsWith: (prefix, message) => {
+        return (value, field) => {
+            if (typeof value === 'string' && !value.startsWith(prefix)) {
+                return {
+                    field,
+                    message: message || `Field must start with "${prefix}"`,
+                    type: 'startsWith'
+                };
+            }
+            return null;
+        };
+    },
+
+    endsWith: (suffix, message) => {
+        return (value, field) => {
+            if (typeof value === 'string' && !value.endsWith(suffix)) {
+                return {
+                    field,
+                    message: message || `Field must end with "${suffix}"`,
+                    type: 'endsWith'
+                };
+            }
+            return null;
+        };
+    }
+};
+
+function validate(schema) {
+    return (req, res, next) => {
+        try {
+            schema.validate(req.body);
+            next();
+        } catch (error) {
+            if (error instanceof ValidationError) {
+                return res.status(400).json({
+                    success: false,
+                    message: 'Validation failed',
+                    errors: error.errors
+                });
+            }
+            throw error;
+        }
+    };
+}
+
+function validatePartial(schema) {
+    const partial = {};
+
+    for (const field in schema.fields) {
+        const rules = schema.fields[field];
+
+        const filtered = rules.filter(v =>
+            v.name !== 'required' &&
+            v.name !== 'requiredTrue' &&
+            v.name !== 'mustBeTrue'
+        );
+        partial[field] = [validators.optional(), ...filtered];
+    }
+
+    return new Schema(partial);
+}
+
+module.exports = {
+    Schema,
+    ValidationError,
+    validators,
+    validate,
+    validatePartial,
+
+    schema: (...args) => new Schema(...args),
+    v: validators,
+    validator: validators,
+    middleware: {
+        validate,
+        validatePartial
+    }
+};

package/lib/static.js

@@ -0,0 +1,247 @@
+const fs = require('fs');
+const path = require('path');
+
+module.exports = function serveStatic(root, options = {}) {
+    const opts = {
+        maxAge: options.maxAge || 0,
+        index: options.index !== undefined ? options.index : 'index.html',
+        dotfiles: options.dotfiles || 'ignore',
+        etag: options.etag !== undefined ? options.etag : true,
+        extensions: options.extensions || false,
+        fallthrough: options.fallthrough !== undefined ? options.fallthrough : true,
+        immutable: options.immutable || false,
+        lastModified: options.lastModified !== undefined ? options.lastModified : true,
+        redirect: options.redirect !== undefined ? options.redirect : true,
+        setHeaders: options.setHeaders || null,
+        cacheControl: options.cacheControl !== undefined ? options.cacheControl : true
+    };
+
+    const mimeTypes = {
+        '.html': 'text/html; charset=utf-8',
+        '.htm': 'text/html; charset=utf-8',
+        '.css': 'text/css; charset=utf-8',
+        '.js': 'application/javascript; charset=utf-8',
+        '.mjs': 'application/javascript; charset=utf-8',
+        '.json': 'application/json; charset=utf-8',
+        '.xml': 'application/xml; charset=utf-8',
+        '.txt': 'text/plain; charset=utf-8',
+        '.md': 'text/markdown; charset=utf-8',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.png': 'image/png',
+        '.gif': 'image/gif',
+        '.svg': 'image/svg+xml',
+        '.webp': 'image/webp',
+        '.ico': 'image/x-icon',
+        '.bmp': 'image/bmp',
+        '.tiff': 'image/tiff',
+        '.tif': 'image/tiff',
+        '.mp3': 'audio/mpeg',
+        '.wav': 'audio/wav',
+        '.ogg': 'audio/ogg',
+        '.m4a': 'audio/mp4',
+        '.aac': 'audio/aac',
+        '.flac': 'audio/flac',
+        '.mp4': 'video/mp4',
+        '.webm': 'video/webm',
+        '.ogv': 'video/ogg',
+        '.avi': 'video/x-msvideo',
+        '.mov': 'video/quicktime',
+        '.wmv': 'video/x-ms-wmv',
+        '.flv': 'video/x-flv',
+        '.mkv': 'video/x-matroska',
+        '.woff': 'font/woff',
+        '.woff2': 'font/woff2',
+        '.ttf': 'font/ttf',
+        '.otf': 'font/otf',
+        '.eot': 'application/vnd.ms-fontobject',
+        '.zip': 'application/zip',
+        '.rar': 'application/x-rar-compressed',
+        '.tar': 'application/x-tar',
+        '.gz': 'application/gzip',
+        '.7z': 'application/x-7z-compressed',
+        '.pdf': 'application/pdf',
+        '.doc': 'application/msword',
+        '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        '.xls': 'application/vnd.ms-excel',
+        '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        '.ppt': 'application/vnd.ms-powerpoint',
+        '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+        '.wasm': 'application/wasm',
+        '.csv': 'text/csv; charset=utf-8'
+    };
+
+    const getMimeType = (filePath) => {
+        const ext = path.extname(filePath).toLowerCase();
+        return mimeTypes[ext] || 'application/octet-stream';
+    };
+
+    const generateETag = (stats) => {
+        const mtime = stats.mtime.getTime().toString(16);
+        const size = stats.size.toString(16);
+        return `W/"${size}-${mtime}"`;
+    };
+
+    return async (req, res, next) => {
+        if (req.method !== 'GET' && req.method !== 'HEAD') {
+            return next();
+        }
+
+        try {
+            let pathname = req.url;
+            const qIndex = pathname.indexOf('?');
+            if (qIndex !== -1) {
+                pathname = pathname.substring(0, qIndex);
+            }
+
+            if (pathname === '') {
+                pathname = '/';
+            }
+
+            try {
+                pathname = decodeURIComponent(pathname);
+            } catch (e) {
+                if (opts.fallthrough) return next();
+                return res.status(400).send('Bad Request');
+            }
+
+            let filePath = pathname === '/' ? root : path.join(root, pathname);
+
+            const resolvedPath = path.resolve(filePath);
+            const resolvedRoot = path.resolve(root);
+
+            if (!resolvedPath.startsWith(resolvedRoot)) {
+                if (opts.fallthrough) return next();
+                return res.status(403).send('Forbidden');
+            }
+
+            let stats;
+            try {
+                stats = await fs.promises.stat(filePath);
+            } catch (err) {
+                if (pathname === '/' && opts.index) {
+                    const indexes = Array.isArray(opts.index) ? opts.index : [opts.index];
+                    for (const indexFile of indexes) {
+                        const indexPath = path.join(root, indexFile);
+                        try {
+                            stats = await fs.promises.stat(indexPath);
+                            if (stats.isFile()) {
+                                filePath = indexPath;
+                                break;
+                            }
+                        } catch (e) { }
+                    }
+                }
+
+                if (!stats && opts.extensions && Array.isArray(opts.extensions)) {
+                    let found = false;
+                    for (const ext of opts.extensions) {
+                        const testPath = filePath + (ext.startsWith('.') ? ext : '.' + ext);
+                        try {
+                            stats = await fs.promises.stat(testPath);
+                            filePath = testPath;
+                            found = true;
+                            break;
+                        } catch (e) { }
+                    }
+                    if (!found) return next();
+                } else if (!stats) {
+                    return next();
+                }
+            }
+
+            if (stats.isDirectory()) {
+                if (opts.redirect && !pathname.endsWith('/')) {
+                    const query = qIndex !== -1 ? req.url.substring(qIndex) : '';
+                    const redirectUrl = pathname + '/' + query;
+                    return res.redirect(redirectUrl, 301);
+                }
+
+                if (opts.index) {
+                    const indexes = Array.isArray(opts.index) ? opts.index : [opts.index];
+
+                    for (const indexFile of indexes) {
+                        const indexPath = path.join(filePath, indexFile);
+                        try {
+                            const indexStats = await fs.promises.stat(indexPath);
+                            if (indexStats.isFile()) {
+                                filePath = indexPath;
+                                stats = indexStats;
+                                break;
+                            }
+                        } catch (e) { }
+                    }
+
+                    if (stats.isDirectory()) {
+                        if (opts.fallthrough) return next();
+                        return res.status(404).send('Not Found');
+                    }
+                } else {
+                    if (opts.fallthrough) return next();
+                    return res.status(404).send('Not Found');
+                }
+            }
+
+            if (opts.etag) {
+                const etag = generateETag(stats);
+                const ifNoneMatch = req.headers['if-none-match'];
+
+                if (ifNoneMatch === etag) {
+                    res.statusCode = 304;
+                    res.end();
+                    return;
+                }
+
+                res.setHeader('ETag', etag);
+            }
+
+            if (opts.lastModified) {
+                const lastModified = stats.mtime.toUTCString();
+                const ifModifiedSince = req.headers['if-modified-since'];
+
+                if (ifModifiedSince === lastModified) {
+                    res.statusCode = 304;
+                    res.end();
+                    return;
+                }
+
+                res.setHeader('Last-Modified', lastModified);
+            }
+
+            if (opts.cacheControl) {
+                let cacheControl = 'public';
+
+                if (opts.maxAge > 0) {
+                    cacheControl += `, max-age=${opts.maxAge}`;
+                }
+
+                if (opts.immutable) {
+                    cacheControl += ', immutable';
+                }
+
+                res.setHeader('Cache-Control', cacheControl);
+            }
+
+            const mimeType = getMimeType(filePath);
+            res.setHeader('Content-Type', mimeType);
+            res.setHeader('Content-Length', stats.size);
+
+            if (typeof opts.setHeaders === 'function') {
+                opts.setHeaders(res, filePath, stats);
+            }
+
+            if (req.method === 'HEAD') {
+                return res.end();
+            }
+
+            const data = await fs.promises.readFile(filePath);
+            res.end(data);
+            return;
+
+        } catch (error) {
+            console.error('Static middleware error:', error);
+            if (opts.fallthrough) return next();
+            res.status(500).send('Internal Server Error');
+        }
+    };
+};

package/lieko-express.js

@@ -61,127 +61,53 @@ class LiekoExpress {
       exposedHeaders: [],
       debug: false
     };
-  }
-
-  cors(options = {}) {
-    this.corsOptions = {
-      ...this.corsOptions,
-      enabled: true,
-      ...options
-    };
-  }
-
-  _matchOrigin(origin, allowedOrigin) {
-    if (!origin || !allowedOrigin) return false;
-
-    if (Array.isArray(allowedOrigin)) {
-      return allowedOrigin.some(o => this._matchOrigin(origin, o));
-    }
 
-    if (allowedOrigin === "*") return true;
-
-    // Wildcard https://*.example.com
-    if (allowedOrigin.includes("*")) {
-      const regex = new RegExp("^" + allowedOrigin
-        .replace(/\./g, "\\.")
-        .replace(/\*/g, ".*") + "$");
-
-      return regex.test(origin);
-    }
-
-    return origin === allowedOrigin;
+    this.excludedPatterns = [
+      /^\/\.well-known\/.*/i // Chrome DevTools, Apple, etc.
+    ]
   }
 
-  _applyCors(req, res, opts) {
-    if (!opts || !opts.enabled) return;
-
-    const requestOrigin = req.headers.origin || "";
+  excludeUrl(patterns) {
+    if (!Array.isArray(patterns)) patterns = [patterns];
+    this.excludedPatterns = this.excludedPatterns || [];
 
-    let finalOrigin = "*";
-
-    if (opts.strictOrigin && requestOrigin) {
-      const allowed = this._matchOrigin(requestOrigin, opts.origin);
-
-      if (!allowed) {
-        res.statusCode = 403;
-        return res.end(JSON.stringify({
-          success: false,
-          error: "Origin Forbidden",
-          message: `Origin "${requestOrigin}" is not allowed`
-        }));
+    patterns.forEach(pattern => {
+      if (pattern instanceof RegExp) {
+        this.excludedPatterns.push(pattern);
+        return;
       }
-    }
 
-    if (opts.origin === "*") {
-      finalOrigin = "*";
-    } else if (Array.isArray(opts.origin)) {
-      const match = opts.origin.find(o => this._matchOrigin(requestOrigin, o));
-      finalOrigin = match || opts.origin[0];
-    } else {
-      finalOrigin = this._matchOrigin(requestOrigin, opts.origin)
-        ? requestOrigin
-        : opts.origin;
-    }
+      let regexStr = pattern
+        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&') 
+        .replace(/\\\*/g, '.*');
 
-    this._logCorsDebug(req, {
-      ...opts,
-      origin: finalOrigin
+      regexStr = '^' + regexStr + '$';
+      this.excludedPatterns.push(new RegExp(regexStr, 'i'));
     });
 
-    res.setHeader("Access-Control-Allow-Origin", finalOrigin);
-
-    if (opts.credentials) {
-      res.setHeader("Access-Control-Allow-Credentials", "true");
-    }
-
-    if (opts.exposedHeaders?.length) {
-      res.setHeader("Access-Control-Expose-Headers",
-        opts.exposedHeaders.join(", "));
-    }
-
-    // Chrome Private Network Access
-    if (
-      opts.allowPrivateNetwork &&
-      req.headers["access-control-request-private-network"] === "true"
-    ) {
-      res.setHeader("Access-Control-Allow-Private-Network", "true");
-    }
-
-    if (req.method === "OPTIONS") {
-      res.setHeader("Access-Control-Allow-Methods", opts.methods.join(", "));
-      res.setHeader("Access-Control-Allow-Headers", opts.headers.join(", "));
-      res.setHeader("Access-Control-Max-Age", opts.maxAge);
-
-      res.statusCode = 204;
-      return res.end();
-    }
+    return this;
   }
 
-  _logCorsDebug(req, opts) {
-    if (!opts.debug) return;
-
-    console.log("\n[CORS DEBUG]");
-    console.log("Request:", req.method, req.url);
-    console.log("Origin:", req.headers.origin || "none");
-
-    console.log("Applied CORS Policy:");
-    console.log("  - Access-Control-Allow-Origin:", opts.origin);
-    console.log("  - Access-Control-Allow-Methods:", opts.methods.join(", "));
-    console.log("  - Access-Control-Allow-Headers:", opts.headers.join(", "));
-
-    if (opts.credentials) {
-      console.log("  - Access-Control-Allow-Credentials: true");
-    }
+  _isExcluded(url) {
+    if (!this.excludedPatterns?.length) return false;
+    return this.excludedPatterns.some(re => re.test(url));
+  }
 
-    if (opts.exposedHeaders?.length) {
-      console.log("  - Access-Control-Expose-Headers:", opts.exposedHeaders.join(", "));
+  cors(options = {}) {
+    if (options === false) {
+      this._corsMiddleware = null;
+      return this;
     }
 
-    console.log("  - Max-Age:", opts.maxAge);
+    const middleware = require('./lib/cors')(options);
+    this._corsMiddleware = middleware;
 
-    if (req.method === "OPTIONS") {
-      console.log("Preflight request handled with status 204\n");
+    const stack = new Error().stack;
+    if (!stack.includes('at LiekoExpress.use')) {
+      this.use(middleware);
     }
+
+    return middleware;
   }
 
   debug(value = true) {
@@ -708,248 +634,7 @@ ${cyan}    (req, res, next) => {
   }
 
   static(root, options = {}) {
-    const opts = {
-      maxAge: options.maxAge || 0,
-      index: options.index !== undefined ? options.index : 'index.html',
-      dotfiles: options.dotfiles || 'ignore',
-      etag: options.etag !== undefined ? options.etag : true,
-      extensions: options.extensions || false,
-      fallthrough: options.fallthrough !== undefined ? options.fallthrough : true,
-      immutable: options.immutable || false,
-      lastModified: options.lastModified !== undefined ? options.lastModified : true,
-      redirect: options.redirect !== undefined ? options.redirect : true,
-      setHeaders: options.setHeaders || null,
-      cacheControl: options.cacheControl !== undefined ? options.cacheControl : true
-    };
-
-    const mimeTypes = {
-      '.html': 'text/html; charset=utf-8',
-      '.htm': 'text/html; charset=utf-8',
-      '.css': 'text/css; charset=utf-8',
-      '.js': 'application/javascript; charset=utf-8',
-      '.mjs': 'application/javascript; charset=utf-8',
-      '.json': 'application/json; charset=utf-8',
-      '.xml': 'application/xml; charset=utf-8',
-      '.txt': 'text/plain; charset=utf-8',
-      '.md': 'text/markdown; charset=utf-8',
-      '.jpg': 'image/jpeg',
-      '.jpeg': 'image/jpeg',
-      '.png': 'image/png',
-      '.gif': 'image/gif',
-      '.svg': 'image/svg+xml',
-      '.webp': 'image/webp',
-      '.ico': 'image/x-icon',
-      '.bmp': 'image/bmp',
-      '.tiff': 'image/tiff',
-      '.tif': 'image/tiff',
-      '.mp3': 'audio/mpeg',
-      '.wav': 'audio/wav',
-      '.ogg': 'audio/ogg',
-      '.m4a': 'audio/mp4',
-      '.aac': 'audio/aac',
-      '.flac': 'audio/flac',
-      '.mp4': 'video/mp4',
-      '.webm': 'video/webm',
-      '.ogv': 'video/ogg',
-      '.avi': 'video/x-msvideo',
-      '.mov': 'video/quicktime',
-      '.wmv': 'video/x-ms-wmv',
-      '.flv': 'video/x-flv',
-      '.mkv': 'video/x-matroska',
-      '.woff': 'font/woff',
-      '.woff2': 'font/woff2',
-      '.ttf': 'font/ttf',
-      '.otf': 'font/otf',
-      '.eot': 'application/vnd.ms-fontobject',
-      '.zip': 'application/zip',
-      '.rar': 'application/x-rar-compressed',
-      '.tar': 'application/x-tar',
-      '.gz': 'application/gzip',
-      '.7z': 'application/x-7z-compressed',
-      '.pdf': 'application/pdf',
-      '.doc': 'application/msword',
-      '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-      '.xls': 'application/vnd.ms-excel',
-      '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-      '.ppt': 'application/vnd.ms-powerpoint',
-      '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-      '.wasm': 'application/wasm',
-      '.csv': 'text/csv; charset=utf-8'
-    };
-
-    const getMimeType = (filePath) => {
-      const ext = path.extname(filePath).toLowerCase();
-      return mimeTypes[ext] || 'application/octet-stream';
-    };
-
-    const generateETag = (stats) => {
-      const mtime = stats.mtime.getTime().toString(16);
-      const size = stats.size.toString(16);
-      return `W/"${size}-${mtime}"`;
-    };
-
-    return async (req, res, next) => {
-      if (req.method !== 'GET' && req.method !== 'HEAD') {
-        return next();
-      }
-
-      try {
-        let pathname = req.url;
-        const qIndex = pathname.indexOf('?');
-        if (qIndex !== -1) {
-          pathname = pathname.substring(0, qIndex);
-        }
-
-        if (pathname === '') {
-          pathname = '/';
-        }
-
-        try {
-          pathname = decodeURIComponent(pathname);
-        } catch (e) {
-          if (opts.fallthrough) return next();
-          return res.status(400).send('Bad Request');
-        }
-
-        let filePath = pathname === '/' ? root : path.join(root, pathname);
-
-        const resolvedPath = path.resolve(filePath);
-        const resolvedRoot = path.resolve(root);
-
-        if (!resolvedPath.startsWith(resolvedRoot)) {
-          if (opts.fallthrough) return next();
-          return res.status(403).send('Forbidden');
-        }
-
-        let stats;
-        try {
-          stats = await fs.promises.stat(filePath);
-        } catch (err) {
-          if (pathname === '/' && opts.index) {
-            const indexes = Array.isArray(opts.index) ? opts.index : [opts.index];
-            for (const indexFile of indexes) {
-              const indexPath = path.join(root, indexFile);
-              try {
-                stats = await fs.promises.stat(indexPath);
-                if (stats.isFile()) {
-                  filePath = indexPath;
-                  break;
-                }
-              } catch (e) { }
-            }
-          }
-
-          if (!stats && opts.extensions && Array.isArray(opts.extensions)) {
-            let found = false;
-            for (const ext of opts.extensions) {
-              const testPath = filePath + (ext.startsWith('.') ? ext : '.' + ext);
-              try {
-                stats = await fs.promises.stat(testPath);
-                filePath = testPath;
-                found = true;
-                break;
-              } catch (e) { }
-            }
-            if (!found) return next();
-          } else if (!stats) {
-            return next();
-          }
-        }
-
-        if (stats.isDirectory()) {
-          if (opts.redirect && !pathname.endsWith('/')) {
-            const query = qIndex !== -1 ? req.url.substring(qIndex) : '';
-            const redirectUrl = pathname + '/' + query;
-            return res.redirect(redirectUrl, 301);
-          }
-
-          if (opts.index) {
-            const indexes = Array.isArray(opts.index) ? opts.index : [opts.index];
-
-            for (const indexFile of indexes) {
-              const indexPath = path.join(filePath, indexFile);
-              try {
-                const indexStats = await fs.promises.stat(indexPath);
-                if (indexStats.isFile()) {
-                  filePath = indexPath;
-                  stats = indexStats;
-                  break;
-                }
-              } catch (e) { }
-            }
-
-            if (stats.isDirectory()) {
-              if (opts.fallthrough) return next();
-              return res.status(404).send('Not Found');
-            }
-          } else {
-            if (opts.fallthrough) return next();
-            return res.status(404).send('Not Found');
-          }
-        }
-
-        if (opts.etag) {
-          const etag = generateETag(stats);
-          const ifNoneMatch = req.headers['if-none-match'];
-
-          if (ifNoneMatch === etag) {
-            res.statusCode = 304;
-            res.end();
-            return;
-          }
-
-          res.setHeader('ETag', etag);
-        }
-
-        if (opts.lastModified) {
-          const lastModified = stats.mtime.toUTCString();
-          const ifModifiedSince = req.headers['if-modified-since'];
-
-          if (ifModifiedSince === lastModified) {
-            res.statusCode = 304;
-            res.end();
-            return;
-          }
-
-          res.setHeader('Last-Modified', lastModified);
-        }
-
-        if (opts.cacheControl) {
-          let cacheControl = 'public';
-
-          if (opts.maxAge > 0) {
-            cacheControl += `, max-age=${opts.maxAge}`;
-          }
-
-          if (opts.immutable) {
-            cacheControl += ', immutable';
-          }
-
-          res.setHeader('Cache-Control', cacheControl);
-        }
-
-        const mimeType = getMimeType(filePath);
-        res.setHeader('Content-Type', mimeType);
-        res.setHeader('Content-Length', stats.size);
-
-        if (typeof opts.setHeaders === 'function') {
-          opts.setHeaders(res, filePath, stats);
-        }
-
-        if (req.method === 'HEAD') {
-          return res.end();
-        }
-
-        const data = await fs.promises.readFile(filePath);
-        res.end(data);
-        return;
-
-      } catch (error) {
-        console.error('Static middleware error:', error);
-        if (opts.fallthrough) return next();
-        res.status(500).send('Internal Server Error');
-      }
-    };
+    return require('./lib/static')(root, options);
   }
 
   _mountRouter(basePath, router) {
@@ -1226,6 +911,10 @@ ${cyan}    (req, res, next) => {
   }
 
   async _handleRequest(req, res) {
+    if (this._isExcluded(req.url.split('?')[0])) {
+      return res.status(404).end();
+    }
+
     this._enhanceRequest(req);
 
     const url = req.url;
@@ -1426,6 +1115,90 @@ ${cyan}    (req, res, next) => {
       return undefined;
     };
     req.header = req.get;
+
+    const parseAccept = (header) => {
+      if (!header) return [];
+      return header
+        .split(',')
+        .map(part => {
+          const [type, ...rest] = part.trim().split(';');
+          const q = rest
+            .find(p => p.trim().startsWith('q='))
+            ?.split('=')[1];
+          const quality = q ? parseFloat(q) : 1.0;
+          return { type: type.trim().toLowerCase(), quality };
+        })
+        .filter(item => item.quality > 0)
+        .sort((a, b) => b.quality - a.quality)
+        .map(item => item.type);
+    };
+
+    const accepts = (types) => {
+      if (!Array.isArray(types)) types = [types];
+      const accepted = parseAccept(req.headers['accept']);
+
+      for (const type of types) {
+        const t = type.toLowerCase();
+
+        if (accepted.includes(t)) return type;
+
+        if (accepted.some(a => {
+          if (a === '*/*') return true;
+          if (a.endsWith('/*')) {
+            const prefix = a.slice(0, -1);
+            return t.startsWith(prefix);
+          }
+          return false;
+        })) {
+          return type;
+        }
+      }
+
+      return false;
+    };
+
+    req.accepts = function (types) {
+      return accepts(types);
+    };
+
+    req.acceptsLanguages = function (langs) {
+      if (!Array.isArray(langs)) langs = [langs];
+      const accepted = parseAccept(req.headers['accept-language'] || '');
+      for (const lang of langs) {
+        const l = lang.toLowerCase();
+        if (accepted.some(a => a === l || a.startsWith(l + '-'))) return lang;
+      }
+      return false;
+    };
+
+    req.acceptsEncodings = function (encodings) {
+      if (!Array.isArray(encodings)) encodings = [encodings];
+      const accepted = parseAccept(req.headers['accept-encoding'] || '');
+      for (const enc of encodings) {
+        if (accepted.includes(enc.toLowerCase())) return enc;
+      }
+      return false;
+    };
+
+    req.acceptsCharsets = function (charsets) {
+      if (!Array.isArray(charsets)) charsets = [charsets];
+      const accepted = parseAccept(req.headers['accept-charset'] || '');
+      for (const charset of charsets) {
+        if (accepted.includes(charset.toLowerCase())) return charset;
+      }
+      return false;
+    };
+
+    req.is = function (type) {
+      const ct = (req.headers['content-type'] || '').split(';')[0].trim().toLowerCase();
+      if (!type) return ct;
+      const t = type.toLowerCase();
+      if (t.includes('/')) return ct === t;
+      if (t === 'json') return ct.includes('json');
+      if (t === 'urlencoded') return ct.includes('x-www-form-urlencoded');
+      if (t === 'multipart') return ct.includes('multipart');
+      return false;
+    };
   }
 
   _enhanceResponse(req, res) {
@@ -1572,12 +1345,6 @@ ${cyan}    (req, res, next) => {
               callback(null, html);
               resolve();
             } else {
-              /*
-              HBS cause error header already sent here ??
-              */
-              //res.statusCode = statusCode || 200;
-              //res.setHeader('Content-Type', 'text/html; charset=utf-8');
-              //responseSent = true;
               res.html(html);
               resolve();
             }
@@ -1841,7 +1608,7 @@ ${cyan}    (req, res, next) => {
     logLines.push('---------------------------------------------');
     console.log('\n' + logLines.join('\n') + '\n');
   }
-  
+
   listRoutes() {
     const routeEntries = [];
 
@@ -1916,7 +1683,6 @@ ${cyan}    (req, res, next) => {
   listen() {
     const args = Array.from(arguments);
     const server = createServer(this._handleRequest.bind(this));
-
     server.listen.apply(server, args);
     this.server = server;
     return server;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lieko-express",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "repository": {
     "type": "git",
     "url": "https://github.com/eiwSrvt/lieko-express"
@@ -18,6 +18,7 @@
   "files": [
     "lieko-express.js",
     "lieko-express.d.ts",
-    "README.md"
+    "README.md",
+    "lib"
   ]
 }