mockapi-msi 2.0.1 → 2.4.0

package/modules/core.js

@@ -1,111 +1,289 @@
-const parser = require('./urlParser');
-const http = require('http');
-const constants = require('./constants');
-const handlerLoader = require('./configurationParser');
-
-class Core {
-
-    _logger = null;
-    _port = 0;
-    _enableCors = false;
-    _endpointList = [];
-    _logLevel = ""
-    _modulesProxy = null;
-    _configurations = null;
-    _data = null;
-
-    constructor(logger, configurations, modulesProxy) {
-        this._configurations = configurations;
-        this._logger = logger;
-        this._port = configurations.port;
-        this._enableCors = configurations.enableCors;
-        this._endpointList = configurations.endpoints;
-        this._modulesProxy = modulesProxy;
-
-        this._data = configurations.data || { };
-        handlerLoader.loadHandlersFromConfiguration(this._data);
-    }
-
-    run() {
-        const self = this;
-
-        http.createServer((request, response) => {
-            let bodyPayload = [];
-        
-            request.on('data', (chunk) => {
-                bodyPayload.push(chunk);
-            }).on('end', () => {
-                bodyPayload = Buffer.concat(bodyPayload).toString();
-        
-                const urlInformation = parser.parse(request.url);
-        
-                self._logger.info(`Requesting: ${urlInformation.base} - Verb: ${request.method}`);
-        
-                if (bodyPayload !== '') {
-                    self._logger.info(`Incoming body: ${bodyPayload}`);
-                }
-        
-                let actionFound = false;
-                let responseBody = null;
-                let responseStatus = null;
-                let contentType = null;
-        
-                for (const endpointUrl in self._endpointList) {
-                    if (Object.hasOwnProperty.call(self._endpointList, endpointUrl)) {
-                        const endpoint = self._endpointList[endpointUrl];
-                        const requestMethod = request.method.toLowerCase();
-                        
-                        if (
-                            endpointUrl === urlInformation.base && 
-                            (endpoint.verb === "any" || endpoint.verb.toLowerCase() === requestMethod)
-                        ) {
-        
-                            if (endpoint.data !== undefined && self._data[endpoint.data] === undefined) {
-                                self._logger.error("No matching data variable for this request");
-                                break;
-                            }
-        
-                            actionFound = true;
-                            contentType = endpoint.responseContentType;
-        
-                            try {
-                                const processData = endpoint.data === undefined ?
-                                    "" : 
-                                    self._data[endpoint.data].dataHandler(urlInformation);
-        
-                                responseBody = endpoint.handler !== undefined ?
-                                    self._modulesProxy.execute(endpoint.handler, { 
-                                        method: requestMethod, 
-                                        url: endpointUrl, 
-                                        body: bodyPayload
-                                    }, processData) : processData;
-                                
-                                responseStatus = endpoint.responseStatus;
-                            } catch(ex) {
-                                self._logger.error(`${ex.message}`);
-        
-                                responseStatus = ex.httpStatusCode;
-                                responseBody = ex.message;
-                            }
-                            
-                            break;
-                        }
-                    }
-                }
-        
-                response.statusCode = responseStatus || 
-                    (!actionFound ? 
-                        constants.HTTP_STATUS_CODES.NOT_FOUND : 
-                        constants.HTTP_STATUS_CODES.OK);
-        
-                response.setHeader('Content-Type', contentType || constants.DEFAULT_CONTENT_TYPE);
-                
-                self._enableCors && response.setHeader('Access-Control-Allow-Origin', '*');
-        
-                response.end(responseBody);
-            });
-        }).listen(self._port);
-    }
-}
-
+const parser = require('./urlParser');
+const http = require('http');
+const https = require('https');
+const path = require('path');
+const fs = require('fs');
+const constants = require('./constants');
+const handlerLoader = require('./configurationParser');
+
+const MIME_TYPES = {
+    '.html': 'text/html',
+    '.css': 'text/css',
+    '.js': 'application/javascript',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.txt': 'text/plain',
+    '.xml': 'application/xml',
+    '.pdf': 'application/pdf'
+};
+
+class Core {
+
+    _logger = null;
+    _port = 0;
+    _cors = null;
+    _endpointList = [];
+    _logLevel = ""
+    _modulesProxy = null;
+    _configurations = null;
+    _data = null;
+    _staticPath = null;
+    _connections = new Set();
+    _tls = null;
+
+    constructor(logger, configurations, modulesProxy) {
+        this._configurations = configurations;
+        this._logger = logger;
+        this._port = configurations.port;
+        this._cors = this._parseCors(configurations.enableCors);
+        this._endpointList = configurations.endpoints;
+        this._modulesProxy = modulesProxy;
+        this._staticPath = configurations.staticPath || null;
+        this._tls = this._parseTls(configurations.tls);
+
+        this._data = configurations.data || { };
+        handlerLoader.loadHandlersFromConfiguration(this._data);
+    }
+
+    _parseTls(tlsConfig) {
+        if (!tlsConfig || !tlsConfig.cert || !tlsConfig.key) return null;
+
+        try {
+            return {
+                cert: fs.readFileSync(tlsConfig.cert),
+                key: fs.readFileSync(tlsConfig.key)
+            };
+        } catch (error) {
+            this._logger.error(`Failed to load TLS certificates: ${error.message}`);
+            return null;
+        }
+    }
+
+    _parseCors(corsConfig) {
+        if (!corsConfig) return null;
+
+        if (corsConfig === true) {
+            return { origins: '*', methods: '*', headers: '*' };
+        }
+
+        return {
+            origins: corsConfig.origins || '*',
+            methods: corsConfig.methods || '*',
+            headers: corsConfig.headers || '*'
+        };
+    }
+
+    _applyCorsHeaders(request, response) {
+        if (!this._cors) return false;
+
+        const origin = request.headers['origin'] || '*';
+        const allowedOrigin = this._cors.origins === '*'
+            ? '*'
+            : (this._cors.origins.includes(origin) ? origin : null);
+
+        if (!allowedOrigin) return false;
+
+        response.setHeader('Access-Control-Allow-Origin', allowedOrigin);
+
+        const methods = this._cors.methods === '*'
+            ? 'GET, POST, PUT, DELETE, PATCH, OPTIONS'
+            : (Array.isArray(this._cors.methods) ? this._cors.methods.join(', ') : this._cors.methods);
+        response.setHeader('Access-Control-Allow-Methods', methods);
+
+        const headers = this._cors.headers === '*'
+            ? 'Content-Type, Authorization, X-Requested-With'
+            : (Array.isArray(this._cors.headers) ? this._cors.headers.join(', ') : this._cors.headers);
+        response.setHeader('Access-Control-Allow-Headers', headers);
+
+        return true;
+    }
+
+    _serveStaticFile(request, response, urlPath) {
+        const safePath = path.normalize(urlPath).replace(/^(\.\.[/\\])+/, '');
+        const filePath = path.join(this._staticPath, safePath);
+        const resolvedPath = path.resolve(filePath);
+        const resolvedStatic = path.resolve(this._staticPath);
+
+        if (!resolvedPath.startsWith(resolvedStatic)) {
+            response.statusCode = constants.HTTP_STATUS_CODES.FORBIDDEN;
+            response.end('Forbidden');
+            return;
+        }
+
+        if (!fs.existsSync(resolvedPath) || !fs.statSync(resolvedPath).isFile()) {
+            return false;
+        }
+
+        const ext = path.extname(resolvedPath).toLowerCase();
+        const mimeType = MIME_TYPES[ext] || 'application/octet-stream';
+
+        this._logger.info(`Serving static file: ${resolvedPath}`);
+
+        response.statusCode = constants.HTTP_STATUS_CODES.OK;
+        response.setHeader('Content-Type', mimeType);
+        this._applyCorsHeaders(request, response);
+
+        const stream = fs.createReadStream(resolvedPath);
+        stream.pipe(response);
+
+        return true;
+    }
+
+    run() {
+        const self = this;
+
+        const requestHandler = (request, response) => {
+
+            // Handle CORS preflight requests
+            if (request.method === 'OPTIONS' && self._cors) {
+                self._applyCorsHeaders(request, response);
+                response.statusCode = constants.HTTP_STATUS_CODES.NO_CONTENT;
+                response.end();
+                return;
+            }
+
+            let bodyPayload = [];
+        
+            request.on('data', (chunk) => {
+                bodyPayload.push(chunk);
+            }).on('end', () => {
+                bodyPayload = Buffer.concat(bodyPayload).toString();
+        
+                const urlInformation = parser.parse(request.url);
+        
+                self._logger.info(`Requesting: ${urlInformation.base} - Verb: ${request.method}`);
+        
+                if (bodyPayload !== '') {
+                    self._logger.info(`Incoming body: ${bodyPayload}`);
+                }
+        
+                let actionFound = false;
+                let responseBody = null;
+                let responseStatus = null;
+                let contentType = null;
+                let delay = 0;
+        
+                for (const endpointUrl in self._endpointList) {
+                    if (Object.hasOwnProperty.call(self._endpointList, endpointUrl)) {
+                        const endpoint = self._endpointList[endpointUrl];
+                        const requestMethod = request.method.toLowerCase();
+                        
+                        const pathResult = parser.matchPath(endpointUrl, urlInformation.base);
+
+                        if (
+                            pathResult.match && 
+                            (endpoint.verb === "any" || endpoint.verb.toLowerCase() === requestMethod)
+                        ) {
+        
+                            if (endpoint.data !== undefined && self._data[endpoint.data] === undefined) {
+                                self._logger.error("No matching data variable for this request");
+                                break;
+                            }
+
+                            // Merge path params and query params into urlInformation
+                            urlInformation.params = pathResult.params;
+                            urlInformation.query = Object.fromEntries(urlInformation.search);
+        
+                            actionFound = true;
+                            contentType = endpoint.responseContentType;
+                            delay = endpoint.delay || 0;
+        
+                            try {
+                                const processData = endpoint.data === undefined ?
+                                    "" : 
+                                    self._data[endpoint.data].dataHandler(urlInformation);
+        
+                                responseBody = endpoint.handler !== undefined ?
+                                    self._modulesProxy.execute(endpoint.handler, { 
+                                        method: requestMethod, 
+                                        url: endpointUrl, 
+                                        body: bodyPayload,
+                                        params: urlInformation.params,
+                                        query: urlInformation.query
+                                    }, processData) : processData;
+                                
+                                responseStatus = endpoint.responseStatus;
+                            } catch(ex) {
+                                self._logger.error(`${ex.message}`);
+        
+                                responseStatus = ex.httpStatusCode;
+                                responseBody = ex.message;
+                            }
+                            
+                            break;
+                        }
+                    }
+                }
+        
+                const sendResponse = () => {
+                    // Try static file serving before returning 404
+                    if (!actionFound && self._staticPath) {
+                        const served = self._serveStaticFile(request, response, urlInformation.pathname);
+                        if (served !== false) return;
+                    }
+
+                    response.statusCode = responseStatus || 
+                        (!actionFound ? 
+                            constants.HTTP_STATUS_CODES.NOT_FOUND : 
+                            constants.HTTP_STATUS_CODES.OK);
+        
+                    response.setHeader('Content-Type', contentType || constants.DEFAULT_CONTENT_TYPE);
+                    
+                    self._applyCorsHeaders(request, response);
+        
+                    response.end(responseBody);
+                };
+
+                if (delay > 0) {
+                    self._logger.info(`Delaying response by ${delay}ms`);
+                    setTimeout(sendResponse, delay);
+                } else {
+                    sendResponse();
+                }
+            });
+        };
+
+        this._server = this._tls
+            ? https.createServer(this._tls, requestHandler)
+            : http.createServer(requestHandler);
+
+        this._server.listen(self._port);
+
+        this._server.on('connection', (socket) => {
+            self._connections.add(socket);
+            socket.on('close', () => self._connections.delete(socket));
+        });
+    }
+
+    reload(configurations) {
+        this._configurations = configurations;
+        this._port = configurations.port;
+        this._cors = this._parseCors(configurations.enableCors);
+        this._endpointList = configurations.endpoints;
+        this._staticPath = configurations.staticPath || null;
+
+        this._data = configurations.data || {};
+        handlerLoader.loadHandlersFromConfiguration(this._data);
+
+        this._logger.info('Configuration reloaded');
+    }
+
+    stop(callback) {
+        if (this._server) {
+            this._server.close(callback);
+            for (const socket of this._connections) {
+                socket.destroy();
+            }
+            this._connections.clear();
+        } else if (callback) {
+            callback();
+        }
+    }
+}
+
 module.exports = Core;

package/modules/csv.js

@@ -1,78 +1,122 @@
-let CSV = function (content, properties) {
-    this._content = content;
-    this._properties = properties;
-    this._currentIndex = properties.startIndex;
-    this._data = this._readData();
-    this._formattedData = [];
-
-    this["_" + properties.format]();
-};
-
-CSV.prototype._readData = function () {
-    let data = [];
-    const lines = this._content.split("\r\n");
-
-    for (let index = 0; index < lines.length; index++) {
-        const line = lines[index];
-        const extractedLine = line.match(/(?:,|\n|^)("(?:(?:"")*[^"]*)*"|[^",\n]*|(?:\n|$))/gm);
-        
-        let parsedLine = [];
-
-        for (let i = 0; i < extractedLine.length; i++) {
-            const item = extractedLine[i];
-            parsedLine.push(item);
-        }
-
-        data.push(parsedLine);
-    }
-
-    return data;
-};
-
-CSV.prototype._json = function () {
-    if (this._data.length === 0) return;
-
-    const propertyNames = this._data[0];
-
-    for (let i = 1; i < this._data.length; i++) {
-        const record = this._data[i];
-        let obj = { };
-
-        for (let j = 0; j < record.length; j++) {
-            const data = record[j];
-            obj[propertyNames[j]] = data;
-        }
-
-        this._formattedData.push(obj);
-    }
-};
-
-CSV.prototype._text = function () {
-    this._formattedData = this._data.slice(1);
-};
-
-CSV.prototype._seq = function() {
-    if (this._currentIndex >= this._formattedData.length || this._currentIndex < 0) this._currentIndex = 0;
-
-    const record = this._formattedData[this._currentIndex];
-    this._currentIndex++;
-
-    return record;
-};
-
-CSV.prototype._rand = function() {
-    this._currentIndex = parseInt((Math.random() * this._formattedData.length - 1) + 1);
-    const record = this._formattedData[this._currentIndex];
-
-    return record;
-};
-
-CSV.prototype.read = function () {
-    if (this._currentIndex === -1) {
-        return JSON.stringify(this._formattedData);
-    }
-
-    return JSON.stringify(this["_" + this._properties.direction]());   
-};
-
+class CSV {
+
+    constructor(content, properties) {
+        this._properties = properties;
+        this._currentIndex = properties.startIndex;
+        this._data = this._parseCSV(content);
+        this._formattedData = [];
+
+        this._applyFormat(properties.format);
+    }
+
+    _parseCSV(content) {
+        const rows = [];
+        let currentRow = [];
+        let currentField = '';
+        let insideQuotes = false;
+        let i = 0;
+
+        while (i < content.length) {
+            const char = content[i];
+
+            if (insideQuotes) {
+                if (char === '"') {
+                    if (i + 1 < content.length && content[i + 1] === '"') {
+                        currentField += '"';
+                        i += 2;
+                    } else {
+                        insideQuotes = false;
+                        i++;
+                    }
+                } else {
+                    currentField += char;
+                    i++;
+                }
+            } else {
+                if (char === '"') {
+                    insideQuotes = true;
+                    i++;
+                } else if (char === ',') {
+                    currentRow.push(currentField);
+                    currentField = '';
+                    i++;
+                } else if (char === '\r' && i + 1 < content.length && content[i + 1] === '\n') {
+                    currentRow.push(currentField);
+                    currentField = '';
+                    rows.push(currentRow);
+                    currentRow = [];
+                    i += 2;
+                } else if (char === '\n' || char === '\r') {
+                    currentRow.push(currentField);
+                    currentField = '';
+                    rows.push(currentRow);
+                    currentRow = [];
+                    i++;
+                } else {
+                    currentField += char;
+                    i++;
+                }
+            }
+        }
+
+        if (currentField || currentRow.length > 0) {
+            currentRow.push(currentField);
+            rows.push(currentRow);
+        }
+
+        return rows;
+    }
+
+    _applyFormat(format) {
+        if (typeof this[`_${format}`] === 'function') {
+            this[`_${format}`]();
+        }
+    }
+
+    _json() {
+        if (this._data.length === 0) return;
+
+        const propertyNames = this._data[0];
+
+        for (let i = 1; i < this._data.length; i++) {
+            const record = this._data[i];
+            const obj = {};
+
+            for (let j = 0; j < record.length; j++) {
+                obj[propertyNames[j]] = record[j];
+            }
+
+            this._formattedData.push(obj);
+        }
+    }
+
+    _text() {
+        this._formattedData = this._data.slice(1);
+    }
+
+    _seq() {
+        if (this._currentIndex >= this._formattedData.length || this._currentIndex < 0) {
+            this._currentIndex = 0;
+        }
+
+        const record = this._formattedData[this._currentIndex];
+        this._currentIndex++;
+
+        return record;
+    }
+
+    _rand() {
+        this._currentIndex = Math.floor(Math.random() * this._formattedData.length);
+        return this._formattedData[this._currentIndex];
+    }
+
+    read() {
+        if (this._currentIndex === -1) {
+            return JSON.stringify(this._formattedData);
+        }
+
+        return JSON.stringify(this[`_${this._properties.direction}`]());
+    }
+}
+
 module.exports = CSV;