@reldens/server-utils 0.41.0 → 0.43.0

package/CLAUDE.md

@@ -67,6 +67,8 @@ npm test
   - `appendToFile(filePath, content)` - Append to file
   - `prependToFile(filePath, content)` - Prepend to file
   - `replaceInFile(filePath, searchValue, replaceValue)` - Replace in file
+  - `createReadStream(filePath, options)` - Create readable stream for file
+  - `getFileModificationTime(filePath)` - Get file last modification time
 - All methods include built-in error handling, no need for try/catch
 - DO NOT use FileHandler.exists to validate other FileHandler methods
 - DO NOT enclose FileHandler methods in try/catch blocks
@@ -79,6 +81,7 @@ npm test
   - HTTP/2 CDN server integration
   - Reverse proxy with WebSocket support
   - Development mode detection and configuration
+  - Custom error handling via onError callback
 - Security configurers (modular):
   - `DevelopmentModeDetector` - Auto-detect development environment
   - `ProtocolEnforcer` - HTTP/HTTPS protocol enforcement
@@ -86,6 +89,8 @@ npm test
   - `CorsConfigurer` - CORS with dynamic origin validation
   - `RateLimitConfigurer` - Global and endpoint-specific rate limiting
   - `ReverseProxyConfigurer` - Domain-based reverse proxy
+- Configuration properties:
+  - `onError` - Custom error handler callback for server errors
 - Methods:
   - `createAppServer(config)` - Create and configure server
   - `addDomain(domainConfig)` - Add virtual host domain
@@ -146,15 +151,30 @@ npm test
   - HTTP/1.1 fallback support
   - Security headers (X-Content-Type-Options, X-Frame-Options, Vary)
   - Query string stripping for cache optimization
+  - Comprehensive error handling (server, TLS, session, stream errors)
+  - Custom error handler callback support
+- Configuration properties:
+  - `onError` - Custom error handler callback for server errors
 - Methods:
   - `create()` - Create HTTP/2 secure server
   - `listen()` - Start listening on configured port
   - `close()` - Gracefully close server
   - `handleStream(stream, headers)` - Handle HTTP/2 stream
+  - `handleHttp1Request(req, res)` - Handle HTTP/1.1 fallback requests
   - `resolveFilePath(requestPath)` - Resolve file path from request
+  - `setupEventHandlers()` - Configure server error event handlers
 
 ### Utility Classes
 
+**ServerErrorHandler** (`lib/server-error-handler.js`):
+- Centralized error handling for all server components
+- Static class with standardized error handling interface
+- Methods:
+  - `handleError(onErrorCallback, instanceName, instance, key, error, context)` - Handle and delegate errors
+- Used by Http2CdnServer, AppServerFactory, and ReverseProxyConfigurer
+- Supports custom error callbacks for application-specific error processing
+- Provides structured error context with instance details and metadata
+
 **ServerDefaultConfigurations** (`lib/server-default-configurations.js`):
 - Static class providing default configurations
 - `mimeTypes` - Comprehensive MIME type mappings for common file extensions
@@ -220,10 +240,17 @@ npm test
 - SSL termination
 - Header preservation (X-Forwarded-For, X-Forwarded-Proto, X-Forwarded-Host)
 - Virtual host integration
-- Graceful error handling (502 Bad Gateway, 504 Gateway Timeout)
-- `setup(app, config)` - Setup reverse proxy
-- `createProxyMiddleware(rule)` - Create proxy middleware for rule
-- `handleProxyError(err, req, res)` - Handle proxy errors
+- Comprehensive error handling with proper HTTP status codes:
+  - 502 Bad Gateway for ECONNREFUSED errors
+  - 504 Gateway Timeout for ETIMEDOUT/ESOCKETTIMEDOUT errors
+  - 500 Internal Server Error for other proxy errors
+- Custom error callback support via ServerErrorHandler
+- Methods:
+  - `setup(app, config)` - Setup reverse proxy
+  - `createProxyMiddleware(rule)` - Create proxy middleware for rule
+  - `handleProxyError(err, req, res)` - Handle proxy errors with status codes
+  - `validateProxyRule(rule)` - Validate proxy rule configuration
+  - `extractHostname(req)` - Extract hostname from request
 
 ## Important Notes
 

package/README.md

@@ -25,6 +25,7 @@ A Node.js server toolkit providing secure application server creation, HTTP/2 CD
 - Static file serving with security headers
 - Compression middleware with smart filtering
 - Input validation utilities
+- Custom error handling with callback support
 
 ### Http2CdnServer
 - Dedicated HTTP/2 server for static asset delivery
@@ -37,6 +38,8 @@ A Node.js server toolkit providing secure application server creation, HTTP/2 CD
 - Standalone or integrated with AppServerFactory
 - Multiple static path support
 - Separate SSL certificate support from main server
+- Comprehensive error handling (server, TLS, session, stream errors)
+- Custom error handler callback support
 
 #### Modular Security Components
 The AppServerFactory now uses specialized security configurers:
@@ -47,6 +50,7 @@ The AppServerFactory now uses specialized security configurers:
 - **RateLimitConfigurer** - Global and endpoint-specific rate limiting
 - **ReverseProxyConfigurer** - Domain-based reverse proxy with WebSocket support
 - **SecurityConfigurer** - Helmet integration with CSP management and XSS protection
+- **ServerErrorHandler** - Centralized error handling with custom callback support
 
 ### FileHandler
 - Secure file system operations with path validation
@@ -63,6 +67,8 @@ The AppServerFactory now uses specialized security configurers:
 - Directory walking with callback processing
 - File comparison and relative path calculations
 - Comprehensive error handling with detailed context
+- Read stream creation for efficient file streaming
+- File modification time retrieval
 
 ### Encryptor
 - Password hashing using PBKDF2 with configurable iterations
@@ -174,6 +180,34 @@ if(cdnServer.create()){
 }
 ```
 
+### Custom Error Handling
+
+Configure custom error handlers for server errors:
+
+```javascript
+let appServerFactory = new AppServerFactory();
+
+appServerFactory.onError = (errorData) => {
+    console.error('Server error:', errorData.key);
+    console.error('Error details:', errorData.error);
+    console.error('Context:', errorData);
+};
+
+let serverResult = appServerFactory.createAppServer({
+    port: 443,
+    useHttps: true,
+    http2CdnEnabled: true,
+    autoListen: true
+});
+```
+
+The `onError` callback receives structured error data:
+- `instanceName` - Name of the component (e.g., 'http2CdnServer', 'appServerFactory')
+- `instance` - Reference to the component instance
+- `key` - Error type identifier (e.g., 'server-error', 'tls-client-error', 'proxy-error')
+- `error` - The actual error object
+- `...context` - Additional context data (port, path, hostname, etc.)
+
 ### HTTPS Server with Optimized Caching
 
 ```javascript
@@ -225,6 +259,18 @@ if(FileHandler.createFolder('/path/to/new/folder')){
 // Generate a secure filename
 let secureFilename = FileHandler.generateSecureFilename('user-upload.jpg');
 console.log('Secure filename:', secureFilename);
+
+// Create a read stream for efficient file handling
+let stream = FileHandler.createReadStream('/path/to/large-file.txt');
+if(stream){
+    stream.pipe(response);
+}
+
+// Get file modification time
+let modTime = FileHandler.getFileModificationTime('/path/to/file.txt');
+if(modTime){
+    console.log('Last modified:', modTime);
+}
 ```
 
 ### Password Encryption
@@ -515,7 +561,10 @@ let serverResult = appServerFactory.createAppServer({
 - Header preservation (X-Forwarded-For, X-Forwarded-Proto, X-Forwarded-Host)
 - Virtual host integration
 - Path-based routing
-- Graceful error handling
+- Comprehensive error handling with proper HTTP status codes:
+  - 502 Bad Gateway for connection refused errors
+  - 504 Gateway Timeout for timeout errors
+  - 500 Internal Server Error for other proxy errors
 
 #### Rule Properties
 
@@ -569,6 +618,15 @@ reverseProxyRules: [
 - `reverseProxyEnabled` - Enable reverse proxy (default: false)
 - `reverseProxyRules` - Array of proxy rules (default: [])
 
+### AppServerFactory Error Handling
+
+- `onError` - Custom error handler callback function receiving error data:
+  - `instanceName` - Component name (e.g., 'appServerFactory', 'http2CdnServer')
+  - `instance` - Component instance reference
+  - `key` - Error type identifier (e.g., 'server-error', 'virtual-host-error')
+  - `error` - The error object
+  - Additional context data (port, hostname, path, etc.)
+
 ### Http2CdnServer Methods
 
 - `create()` - Creates HTTP/2 secure server
@@ -591,6 +649,7 @@ reverseProxyRules: [
 - `securityHeaders` - Custom security headers
 - `varyHeader` - Vary header value (default: 'Accept-Encoding, Origin')
 - `mimeTypes` - MIME type mappings
+- `onError` - Custom error handler callback
 
 ### FileHandler Methods
 
@@ -620,6 +679,8 @@ reverseProxyRules: [
 - `walkDirectory(path, callback)` - Recursively processes a directory tree
 - `getDirectorySize(path)` - Calculates total directory size
 - `emptyDirectory(path)` - Removes all contents from directory
+- `createReadStream(path, options)` - Creates readable stream for file
+- `getFileModificationTime(path)` - Gets file last modification time
 
 ### Encryptor Methods
 
@@ -643,6 +704,16 @@ reverseProxyRules: [
 - `validateFileContents(file, allowedType)` - Validates file content after upload
 - `convertToRegex(key)` - Converts MIME type patterns to regex
 
+### ServerErrorHandler Methods
+
+- `handleError(onErrorCallback, instanceName, instance, key, error, context)` - Static method for centralized error handling
+  - `onErrorCallback` - Custom error handler function (optional)
+  - `instanceName` - Name of the component ('http2CdnServer', 'appServerFactory', etc.)
+  - `instance` - Reference to the component instance
+  - `key` - Error type identifier
+  - `error` - The error object
+  - `context` - Additional context object (port, hostname, path, etc.)
+
 ## Security Features
 
 ### Path Traversal Protection
@@ -668,7 +739,15 @@ Industry-standard encryption using PBKDF2 for passwords, AES-256-GCM for data en
 
 ## Error Handling
 
-All methods include comprehensive error handling with detailed error objects containing context information. Errors are logged appropriately and never expose sensitive system information.
+All server components include comprehensive error handling with centralized error management through the ServerErrorHandler class. Custom error handlers can be configured via the `onError` callback to process errors according to application requirements. Errors are logged appropriately and never expose sensitive system information.
+
+Error handling features:
+- Centralized error management with ServerErrorHandler
+- Custom error callback support across all components
+- Structured error context with instance details and metadata
+- Graceful HTTP status codes for proxy errors (502, 504, 500)
+- TLS and session error handling for HTTP/2 servers
+- Virtual host and SNI certificate error handling
 
 ---
 

package/lib/app-server-factory/reverse-proxy-configurer.js

@@ -6,6 +6,7 @@
 
 const { createProxyMiddleware } = require('http-proxy-middleware');
 const { ServerHeaders } = require('../server-headers');
+const { ServerErrorHandler } = require('../server-error-handler');
 
 class ReverseProxyConfigurer
 {
@@ -22,6 +23,7 @@ class ReverseProxyConfigurer
             logLevel: 'warn'
         };
         this.serverHeaders = new ServerHeaders();
+        this.onError = null;
     }
 
     setup(app, config)
@@ -30,6 +32,7 @@ class ReverseProxyConfigurer
         this.useVirtualHosts = config.useVirtualHosts || false;
         this.reverseProxyRules = config.reverseProxyRules || [];
         this.reverseProxyOptions = config.reverseProxyOptions || this.reverseProxyOptions;
+        this.onError = config.onError || null;
         if(0 === this.reverseProxyRules.length){
             return;
         }
@@ -100,7 +103,9 @@ class ReverseProxyConfigurer
             options.logLevel = rule.logLevel;
         }
         options.target = rule.target;
-        options.onError = this.handleProxyError.bind(this);
+        options.onError = (err, req, res) => {
+            this.handleProxyError(err, req, res);
+        };
         options.onProxyReq = (proxyReq, req) => {
             if(req.headers['x-forwarded-for']){
                 return;
@@ -115,6 +120,16 @@ class ReverseProxyConfigurer
 
     handleProxyError(err, req, res)
     {
+        let hostname = req.get('host') || 'unknown';
+        let requestPath = req.path || req.url || 'unknown';
+        ServerErrorHandler.handleError(
+            this.onError,
+            'reverseProxyConfigurer',
+            this,
+            'proxy-error',
+            err,
+            {request: req, response: res, hostname: hostname, path: requestPath}
+        );
         if(res.headersSent){
             return;
         }

package/lib/app-server-factory.js

@@ -9,6 +9,7 @@ const { Http2CdnServer } = require('./http2-cdn-server');
 const { ServerDefaultConfigurations } = require('./server-default-configurations');
 const { ServerFactoryUtils } = require('./server-factory-utils');
 const { ServerHeaders } = require('./server-headers');
+const { ServerErrorHandler } = require('./server-error-handler');
 const { DevelopmentModeDetector } = require('./app-server-factory/development-mode-detector');
 const { ProtocolEnforcer } = require('./app-server-factory/protocol-enforcer');
 const { SecurityConfigurer } = require('./app-server-factory/security-configurer');
@@ -115,6 +116,7 @@ class AppServerFactory
         this.http2CdnServer = false;
         this.reverseProxyEnabled = false;
         this.reverseProxyRules = [];
+        this.onError = null;
     }
 
     buildStaticHeaders(res, path)
@@ -188,6 +190,7 @@ class AppServerFactory
         }
         this.http2CdnServer.corsOrigins = this.http2CdnCorsOrigins;
         this.http2CdnServer.corsAllowAll = this.http2CdnCorsAllowAll;
+        this.http2CdnServer.onError = this.onError;
         if(!this.http2CdnServer.create()){
             this.error = this.http2CdnServer.error;
             return false;
@@ -350,7 +353,8 @@ class AppServerFactory
         this.reverseProxyConfigurer.setup(this.app, {
             reverseProxyRules: this.reverseProxyRules,
             isDevelopmentMode: this.isDevelopmentMode,
-            useVirtualHosts: this.useVirtualHosts
+            useVirtualHosts: this.useVirtualHosts,
+            onError: this.onError
         });
     }
 
@@ -388,6 +392,14 @@ class AppServerFactory
                     return next();
                 }
                 this.error = {message: 'No hostname provided and no default domain configured'};
+                ServerErrorHandler.handleError(
+                    this.onError,
+                    'appServerFactory',
+                    this,
+                    'virtual-host-no-hostname',
+                    this.error,
+                    {request: req, response: res}
+                );
                 return res.status(400).send('Bad Request');
             }
             let domain = this.findDomainConfig(hostname);
@@ -397,6 +409,14 @@ class AppServerFactory
                     return next();
                 }
                 this.error = {message: 'Unknown domain: '+hostname};
+                ServerErrorHandler.handleError(
+                    this.onError,
+                    'appServerFactory',
+                    this,
+                    'virtual-host-unknown-domain',
+                    this.error,
+                    {hostname: hostname, request: req, response: res}
+                );
                 return res.status(404).send('Domain not found');
             }
             req.domain = domain;
@@ -471,11 +491,27 @@ class AppServerFactory
             let key = FileHandler.readFile(domain.keyPath, 'Domain Key');
             if(!key){
                 this.error = {message: 'Could not read domain SSL key: '+domain.keyPath};
+                ServerErrorHandler.handleError(
+                    this.onError,
+                    'appServerFactory',
+                    this,
+                    'sni-key-read-failure',
+                    this.error,
+                    {hostname: hostname, domain: domain, keyPath: domain.keyPath}
+                );
                 return callback(null, null);
             }
             let cert = FileHandler.readFile(domain.certPath, 'Domain Cert');
             if(!cert){
                 this.error = {message: 'Could not read domain SSL certificate: '+domain.certPath};
+                ServerErrorHandler.handleError(
+                    this.onError,
+                    'appServerFactory',
+                    this,
+                    'sni-cert-read-failure',
+                    this.error,
+                    {hostname: hostname, domain: domain, certPath: domain.certPath}
+                );
                 return callback(null, null);
             }
             let ctx = tls.createSecureContext({key, cert});

package/lib/file-handler.js

@@ -765,6 +765,19 @@ class FileHandler
         return this.writeFile(filePath, content.replace(searchValue, replaceValue));
     }
 
+    createReadStream(filePath, options)
+    {
+        if(!this.isValidPath(filePath)){
+            this.error = {message: 'Invalid file path.', filePath};
+            return false;
+        }
+        if(!this.isFile(filePath)){
+            this.error = {message: 'File does not exist or is not a file.', filePath};
+            return false;
+        }
+        return fs.createReadStream(filePath, options);
+    }
+
 }
 
 module.exports.FileHandler = new FileHandler();

package/lib/http2-cdn-server.js

@@ -5,11 +5,11 @@
  */
 
 const http2 = require('http2');
-const path = require('path');
 const { FileHandler } = require('./file-handler');
 const { ServerDefaultConfigurations } = require('./server-default-configurations');
 const { ServerFactoryUtils } = require('./server-factory-utils');
 const { ServerHeaders } = require('./server-headers');
+const { ServerErrorHandler } = require('./server-error-handler');
 
 class Http2CdnServer
 {
@@ -34,6 +34,7 @@ class Http2CdnServer
         this.corsHeaders = this.serverHeaders.http2CorsHeaders;
         this.securityHeaders = this.serverHeaders.http2SecurityHeaders;
         this.varyHeader = this.serverHeaders.http2VaryHeader;
+        this.onError = null;
     }
 
     create()
@@ -60,71 +61,209 @@ class Http2CdnServer
             }
         }
         this.http2Server = http2.createSecureServer(options);
-        this.setupStreamHandler();
+        this.setupEventHandlers();
         return true;
     }
 
-    setupStreamHandler()
+    setupEventHandlers()
     {
         this.http2Server.on('stream', (stream, headers) => {
             this.handleStream(stream, headers);
         });
+        this.http2Server.on('request', (req, res) => {
+            this.handleHttp1Request(req, res);
+        });
+        this.http2Server.on('error', (err) => {
+            ServerErrorHandler.handleError(
+                this.onError,
+                'http2CdnServer',
+                this,
+                'server-error',
+                err,
+                {port: this.port}
+            );
+        });
+        this.http2Server.on('tlsClientError', (err, tlsSocket) => {
+            ServerErrorHandler.handleError(
+                this.onError,
+                'http2CdnServer',
+                this,
+                'tls-client-error',
+                err,
+                {port: this.port, remoteAddress: tlsSocket.remoteAddress}
+            );
+        });
+        this.http2Server.on('sessionError', (err) => {
+            ServerErrorHandler.handleError(
+                this.onError,
+                'http2CdnServer',
+                this,
+                'session-error',
+                err,
+                {port: this.port}
+            );
+        });
     }
 
     handleStream(stream, headers)
     {
-        let requestPath = headers[':path'];
-        if(!requestPath){
-            stream.respond({':status': 400});
-            stream.end();
-            return;
-        }
-        let requestOrigin = headers['origin'] || '';
-        let allowedOrigin = ServerFactoryUtils.validateOrigin(requestOrigin, this.corsOrigins, this.corsAllowAll);
-        if('OPTIONS' === headers[':method']){
-            let optionsHeaders = {':status': 200};
+        try {
+            let requestPath = headers[':path'];
+            if(!requestPath){
+                stream.respond({':status': 400});
+                stream.end();
+                return;
+            }
+            let requestOrigin = headers['origin'] || '';
+            let allowedOrigin = ServerFactoryUtils.validateOrigin(requestOrigin, this.corsOrigins, this.corsAllowAll);
+            if('OPTIONS' === headers[':method']){
+                let optionsHeaders = {':status': 200};
+                if(allowedOrigin){
+                    optionsHeaders['access-control-allow-origin'] = allowedOrigin;
+                }
+                optionsHeaders['access-control-allow-methods'] = this.corsMethods;
+                optionsHeaders['access-control-allow-headers'] = this.corsHeaders;
+                stream.respond(optionsHeaders);
+                stream.end();
+                return;
+            }
+            let filePath = this.resolveFilePath(requestPath);
+            if(!filePath){
+                stream.respond({':status': 404});
+                stream.end();
+                return;
+            }
+            let ext = FileHandler.extension(filePath);
+            let cacheAge = ServerFactoryUtils.getCacheConfigForPath(filePath, this.cacheConfig);
+            let responseHeaders = {':status': 200};
+            let securityKeys = Object.keys(this.securityHeaders);
+            for(let headerKey of securityKeys){
+                responseHeaders[headerKey] = this.securityHeaders[headerKey];
+            }
             if(allowedOrigin){
-                optionsHeaders['access-control-allow-origin'] = allowedOrigin;
+                responseHeaders['access-control-allow-origin'] = allowedOrigin;
+            }
+            if(this.varyHeader){
+                responseHeaders['vary'] = this.varyHeader;
+            }
+            if(cacheAge){
+                responseHeaders['cache-control'] = 'public, max-age='+cacheAge+', immutable';
+            }
+            if(this.mimeTypes[ext]){
+                responseHeaders['content-type'] = this.mimeTypes[ext];
+            }
+            stream.on('error', (err) => {
+                ServerErrorHandler.handleError(
+                    this.onError,
+                    'http2CdnServer',
+                    this,
+                    'stream-error',
+                    err,
+                    {port: this.port, path: requestPath}
+                );
+            });
+            stream.respondWithFile(filePath, responseHeaders);
+        } catch (err) {
+            ServerErrorHandler.handleError(
+                this.onError,
+                'http2CdnServer',
+                this,
+                'handle-stream-error',
+                err,
+                {port: this.port, path: headers[':path']}
+            );
+            if(!stream.destroyed){
+                stream.respond({':status': 500});
+                stream.end();
             }
-            optionsHeaders['access-control-allow-methods'] = this.corsMethods;
-            optionsHeaders['access-control-allow-headers'] = this.corsHeaders;
-            stream.respond(optionsHeaders);
-            stream.end();
-            return;
-        }
-        let filePath = this.resolveFilePath(requestPath);
-        if(!filePath){
-            stream.respond({':status': 404});
-            stream.end();
-            return;
-        }
-        let ext = path.extname(filePath);
-        let cacheAge = ServerFactoryUtils.getCacheConfigForPath(filePath, this.cacheConfig);
-        let responseHeaders = {':status': 200};
-        let securityKeys = Object.keys(this.securityHeaders);
-        for(let headerKey of securityKeys){
-            responseHeaders[headerKey] = this.securityHeaders[headerKey];
-        }
-        if(allowedOrigin){
-            responseHeaders['access-control-allow-origin'] = allowedOrigin;
-        }
-        if(this.varyHeader){
-            responseHeaders['vary'] = this.varyHeader;
-        }
-        if(cacheAge){
-            responseHeaders['cache-control'] = 'public, max-age='+cacheAge+', immutable';
         }
-        if(this.mimeTypes[ext]){
-            responseHeaders['content-type'] = this.mimeTypes[ext];
+    }
+
+    handleHttp1Request(req, res)
+    {
+        try {
+            let requestPath = req.url;
+            if(!requestPath){
+                res.writeHead(400);
+                res.end();
+                return;
+            }
+            let requestOrigin = req.headers['origin'] || '';
+            let allowedOrigin = ServerFactoryUtils.validateOrigin(requestOrigin, this.corsOrigins, this.corsAllowAll);
+            if('OPTIONS' === req.method){
+                let optionsHeaders = {};
+                if(allowedOrigin){
+                    optionsHeaders['access-control-allow-origin'] = allowedOrigin;
+                }
+                optionsHeaders['access-control-allow-methods'] = this.corsMethods;
+                optionsHeaders['access-control-allow-headers'] = this.corsHeaders;
+                res.writeHead(200, optionsHeaders);
+                res.end();
+                return;
+            }
+            let filePath = this.resolveFilePath(requestPath);
+            if(!filePath){
+                res.writeHead(404);
+                res.end();
+                return;
+            }
+            let ext = FileHandler.extension(filePath);
+            let cacheAge = ServerFactoryUtils.getCacheConfigForPath(filePath, this.cacheConfig);
+            let responseHeaders = {};
+            let securityKeys = Object.keys(this.securityHeaders);
+            for(let headerKey of securityKeys){
+                responseHeaders[headerKey] = this.securityHeaders[headerKey];
+            }
+            if(allowedOrigin){
+                responseHeaders['access-control-allow-origin'] = allowedOrigin;
+            }
+            if(this.varyHeader){
+                responseHeaders['vary'] = this.varyHeader;
+            }
+            if(cacheAge){
+                responseHeaders['cache-control'] = 'public, max-age='+cacheAge+', immutable';
+            }
+            if(this.mimeTypes[ext]){
+                responseHeaders['content-type'] = this.mimeTypes[ext];
+            }
+            let fileStream = FileHandler.createReadStream(filePath);
+            fileStream.on('error', (err) => {
+                ServerErrorHandler.handleError(
+                    this.onError,
+                    'http2CdnServer',
+                    this,
+                    'http1-stream-error',
+                    err,
+                    {port: this.port, path: requestPath}
+                );
+                if(!res.headersSent){
+                    res.writeHead(500);
+                    res.end();
+                }
+            });
+            res.writeHead(200, responseHeaders);
+            fileStream.pipe(res);
+        } catch (err) {
+            ServerErrorHandler.handleError(
+                this.onError,
+                'http2CdnServer',
+                this,
+                'handle-http1-request-error',
+                err,
+                {port: this.port, path: req.url}
+            );
+            if(!res.headersSent){
+                res.writeHead(500);
+                res.end();
+            }
         }
-        stream.respondWithFile(filePath, responseHeaders);
     }
 
     resolveFilePath(requestPath)
     {
         let cleanPath = ServerFactoryUtils.stripQueryString(requestPath);
         for(let staticPath of this.staticPaths){
-            let fullPath = path.join(staticPath, cleanPath);
+            let fullPath = FileHandler.joinPaths(staticPath, cleanPath);
             if(!FileHandler.exists(fullPath)){
                 continue;
             }

package/lib/server-error-handler.js

@@ -0,0 +1,25 @@
+/**
+ *
+ * Reldens - ServerErrorHandler
+ *
+ */
+
+class ServerErrorHandler
+{
+
+    static handleError(onErrorCallback, instanceName, instance, key, error, context = {})
+    {
+        if('function' !== typeof onErrorCallback){
+            return;
+        }
+        onErrorCallback({
+            [instanceName]: instance,
+            key: key,
+            error: error,
+            ...context
+        });
+    }
+
+}
+
+module.exports.ServerErrorHandler = ServerErrorHandler;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/server-utils",
     "scope": "@reldens",
-    "version": "0.41.0",
+    "version": "0.43.0",
     "description": "Reldens - Server Utils",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -39,7 +39,7 @@
         "body-parser": "2.2.1",
         "compression": "1.8.1",
         "cors": "2.8.5",
-        "express": "4.21.2",
+        "express": "4.22.1",
         "express-rate-limit": "8.2.1",
         "express-session": "1.18.2",
         "helmet": "8.1.0",