mockapi-msi 2.0.1 → 2.5.0

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;

package/modules/log.js

@@ -1,39 +1,43 @@
-const constants = require("./constants");
-
-const Log = function(logLevel) {
-    this._logLevel = logLevel || "verbose";
-};
-
-Log.prototype._write = function (message) {
-    const date = (new Date()).toString();
-
-    console.log(`${date} ${message}`);
-};
-
-Log.prototype.debug = function (message) {
-    if (this._logLevel === constants.LOG_LEVELS.DEBUG || this._logLevel === constants.LOG_LEVELS.VERBOSE) {
-        this._write(`${constants.COLOR.fgYellow}[DEBUG]${constants.COLOR.reset} - ${message}`);
-    }
-};
-
-Log.prototype.error = function (message) {
-    if (this._logLevel === constants.LOG_LEVELS.ERROR || this._logLevel === constants.LOG_LEVELS.VERBOSE) {
-        this._write(`${constants.COLOR.fgRed}[ERROR]${constants.COLOR.reset} - ${message}`);
-    }
-};
-
-Log.prototype.info = function (message) {
-    if (this._logLevel === constants.LOG_LEVELS.VERBOSE) {
-        this._write(`${constants.COLOR.fgYellow}[INFO]${constants.COLOR.reset} - ${message}`);
-    }
-};
-
-Log.prototype.detail = function (message) {
-    if (this._logLevel === constants.LOG_LEVELS.VERBOSE) {
-        this._write(`${message}`);
-    }
-};
-
-Log.prototype.message = (message) => console.log(message);
-
+const constants = require("./constants");
+
+class Log {
+
+    constructor(logLevel) {
+        this._logLevel = logLevel || "verbose";
+    }
+
+    _write(message) {
+        const date = (new Date()).toISOString();
+        console.log(`${date} ${message}`);
+    }
+
+    debug(message) {
+        if (this._logLevel === constants.LOG_LEVELS.DEBUG || this._logLevel === constants.LOG_LEVELS.VERBOSE) {
+            this._write(`${constants.COLOR.fgYellow}[DEBUG]${constants.COLOR.reset} - ${message}`);
+        }
+    }
+
+    error(message) {
+        if (this._logLevel === constants.LOG_LEVELS.ERROR || this._logLevel === constants.LOG_LEVELS.VERBOSE) {
+            this._write(`${constants.COLOR.fgRed}[ERROR]${constants.COLOR.reset} - ${message}`);
+        }
+    }
+
+    info(message) {
+        if (this._logLevel === constants.LOG_LEVELS.VERBOSE) {
+            this._write(`${constants.COLOR.fgYellow}[INFO]${constants.COLOR.reset} - ${message}`);
+        }
+    }
+
+    detail(message) {
+        if (this._logLevel === constants.LOG_LEVELS.VERBOSE) {
+            this._write(`${message}`);
+        }
+    }
+
+    message(message) {
+        console.log(message);
+    }
+}
+
 module.exports = Log;

package/modules/moduleProxy.js

@@ -1,55 +1,52 @@
-const constants = require("./constants");
-const HttpException = require('./HttpException');
-
-class Proxy {
-
-    _externalModuleList = {};
-
-    constructor(externalModulePath, logger) {
-        this._externalModuleList = {};
-        this._logger = logger;
-        this._externalModulePath = externalModulePath;
-    }
-
-    async load(modules) {
-        for (const moduleName in modules) {
-            if (Object.hasOwnProperty.call(modules, moduleName)) {
-                const moduleFileName = modules[moduleName];
-                
-                try {
-                    const modulePath = `${this._externalModulePath}${moduleFileName}.js`;
-
-                    this._logger.info(`Attempting to load module ${moduleName} from ${modulePath}`);
-
-                    const module = await import(modulePath);
-
-                    this._externalModuleList[moduleName] = module;
-
-                    this._logger.info(`Module '${moduleName}' was loaded`);
-                } catch (error) {
-                    this._logger.error(`Module '${moduleName}' failed during loading ${error}`);
-                }
-            }
-        }
-    }
-
-    execute(name, requestInformation, data) {
-        for (const moduleName in this._externalModuleList) {
-            if (Object.hasOwnProperty.call(this._externalModuleList, moduleName) && moduleName === name) {
-                const module = this._externalModuleList[moduleName];
-
-                try {
-                    return module.process(requestInformation, data);    
-                } catch (error) {
-                    throw new HttpException(constants.HTTP_STATUS_CODES.INTERNAL_SERVER_ERROR, `Module ${moduleName} failed. ${error}`);
-                }
-                
-            }
-        }
-
-        throw new HttpException(constants.HTTP_STATUS_CODES.INTERNAL_SERVER_ERROR, `Module ${moduleName} doesn't exists`);
-    }
-    
-}
-
+const constants = require("./constants");
+const HttpException = require('./HttpException');
+
+class Proxy {
+
+    _externalModuleList = {};
+
+    constructor(externalModulePath, logger) {
+        this._externalModuleList = {};
+        this._logger = logger;
+        this._externalModulePath = externalModulePath;
+    }
+
+    async load(modules) {
+        for (const moduleName in modules) {
+            if (Object.hasOwnProperty.call(modules, moduleName)) {
+                const moduleFileName = modules[moduleName];
+                
+                try {
+                    const modulePath = `${this._externalModulePath}${moduleFileName}.js`;
+
+                    this._logger.info(`Attempting to load module ${moduleName} from ${modulePath}`);
+
+                    const module = await import(modulePath);
+
+                    this._externalModuleList[moduleName] = module;
+
+                    this._logger.info(`Module '${moduleName}' was loaded`);
+                } catch (error) {
+                    this._logger.error(`Module '${moduleName}' failed during loading ${error}`);
+                }
+            }
+        }
+    }
+
+    execute(name, requestInformation, data) {
+        const module = this._externalModuleList[name];
+
+        if (!module) {
+            throw new HttpException(constants.HTTP_STATUS_CODES.INTERNAL_SERVER_ERROR, `Module ${name} doesn't exist`);
+        }
+
+        try {
+            return module.process(requestInformation, data);
+        } catch (error) {
+            throw new HttpException(constants.HTTP_STATUS_CODES.INTERNAL_SERVER_ERROR, `Module ${name} failed. ${error}`);
+        }
+    }
+    
+}
+
 module.exports = Proxy;

package/modules/openApi.js

@@ -0,0 +1,178 @@
+const http = require('http');
+const constants = require('./constants');
+
+const OPENAPI_VERSION = '3.1.0';
+const DEFAULT_METHODS_FOR_ANY = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options'];
+
+const normalizeMethod = (verb) => {
+    if (typeof verb !== 'string' || verb.trim() === '') return ['get'];
+
+    const method = verb.toLowerCase();
+    return method === 'any' ? DEFAULT_METHODS_FOR_ANY : [method];
+};
+
+const toOpenApiPath = (endpointPath) => {
+    if (typeof endpointPath !== 'string' || endpointPath.trim() === '') return '/';
+    return endpointPath.replace(/:([A-Za-z0-9_]+)/g, '{$1}');
+};
+
+const extractPathParameters = (endpointPath) => {
+    if (typeof endpointPath !== 'string' || endpointPath.trim() === '') return [];
+
+    const pathParameters = endpointPath.match(/:([A-Za-z0-9_]+)/g) || [];
+
+    return pathParameters.map((parameter) => ({
+        name: parameter.substring(1),
+        in: 'path',
+        required: true,
+        schema: { type: 'string' }
+    }));
+};
+
+const getResponseStatusCode = (endpointConfiguration) => {
+    const status = parseInt(endpointConfiguration.responseStatus, 10);
+
+    if (!Number.isNaN(status) && status >= 100 && status <= 599) {
+        return status;
+    }
+
+    return constants.HTTP_STATUS_CODES.OK;
+};
+
+const buildResponseContent = (contentType) => {
+    if (!contentType) return undefined;
+
+    const isJsonContentType = contentType.toLowerCase().includes('json');
+
+    return {
+        [contentType]: {
+            schema: isJsonContentType ? {} : { type: 'string' }
+        }
+    };
+};
+
+const buildOperation = (method, endpointPath, endpointConfiguration) => {
+    const responseStatusCode = getResponseStatusCode(endpointConfiguration);
+    const responseContentType = endpointConfiguration.responseContentType || constants.DEFAULT_CONTENT_TYPE;
+    const responseDescription = http.STATUS_CODES[responseStatusCode] || 'Configured response';
+
+    const operation = {
+        summary: `${method.toUpperCase()} ${toOpenApiPath(endpointPath)}`,
+        responses: {
+            [responseStatusCode]: {
+                description: responseDescription
+            }
+        }
+    };
+
+    const responseContent = buildResponseContent(responseContentType);
+    if (responseContent !== undefined) {
+        operation.responses[responseStatusCode].content = responseContent;
+    }
+
+    const parameters = extractPathParameters(endpointPath);
+    if (parameters.length > 0) {
+        operation.parameters = parameters;
+    }
+
+    const metadata = {};
+    if (endpointConfiguration.data !== undefined) metadata.data = endpointConfiguration.data;
+    if (endpointConfiguration.handler !== undefined) metadata.handler = endpointConfiguration.handler;
+    if (endpointConfiguration.delay !== undefined) metadata.delay = endpointConfiguration.delay;
+
+    if (Object.keys(metadata).length > 0) {
+        operation['x-mockapi'] = metadata;
+    }
+
+    return operation;
+};
+
+const buildSpec = (settings, endpointList) => {
+    const openApiSettings = settings || {};
+    const endpoints = endpointList || {};
+    const paths = {};
+
+    for (const endpointPath in endpoints) {
+        if (!Object.hasOwnProperty.call(endpoints, endpointPath)) continue;
+
+        const endpointConfiguration = endpoints[endpointPath] || {};
+        const openApiPath = toOpenApiPath(endpointPath);
+
+        if (!paths[openApiPath]) {
+            paths[openApiPath] = {};
+        }
+
+        const methods = normalizeMethod(endpointConfiguration.verb);
+        for (const method of methods) {
+            paths[openApiPath][method] = buildOperation(method, endpointPath, endpointConfiguration);
+        }
+    }
+
+    return {
+        openapi: OPENAPI_VERSION,
+        info: {
+            title: openApiSettings.title || 'MockAPI',
+            version: openApiSettings.version || '1.0.0',
+            description: openApiSettings.description || 'OpenAPI definition generated from .mockapi-config.'
+        },
+        servers: [{ url: '/' }],
+        paths
+    };
+};
+
+const escapeHtml = (value) => String(value)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+
+const escapeJsString = (value) => String(value)
+    .replace(/\\/g, '\\\\')
+    .replace(/'/g, "\\'");
+
+const buildDocsPage = (settings) => {
+    const docsSettings = settings || {};
+    const title = escapeHtml(docsSettings.title || 'MockAPI');
+    const specPath = escapeJsString(docsSettings.specPath || '/openapi.json');
+
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${title} - API Docs</title>
+    <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css" />
+    <style>
+      html, body {
+        margin: 0;
+        background: #f6f8fa;
+      }
+      #swagger-ui {
+        min-height: 100vh;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="swagger-ui"></div>
+    <script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
+    <script>
+      window.onload = function() {
+        window.ui = SwaggerUIBundle({
+          url: '${specPath}',
+          dom_id: '#swagger-ui',
+          deepLinking: true,
+          presets: [SwaggerUIBundle.presets.apis],
+          layout: 'BaseLayout'
+        });
+      };
+    </script>
+  </body>
+</html>`;
+};
+
+module.exports = {
+    buildSpec,
+    buildDocsPage,
+    toOpenApiPath
+};

package/modules/readers.js

@@ -1,43 +1,43 @@
-const fs = require('fs');
-const path = require('path');
-const constants = require("./constants");
-const CSV = require('./csv');
-const HttpException = require('./HttpException');
-
-const text_reader = (file) => {
-    return () => {
-        if (!fs.existsSync(file)) {
-            throw new HttpException(constants.HTTP_STATUS_CODES.NOT_FOUND, `File ${file} doesn't exists`);
-        }
-
-        return fs.readFileSync(file, 'utf8');
-    };
-};
-
-const file_exists = (file) => fs.existsSync(file);
-
-const folder_reader = (folder) => {
-    return (urlInformation) => {
-
-        if (!urlInformation.hasFile) {
-            throw new HttpException(constants.HTTP_STATUS_CODES.NOT_ACCEPTABLE, "File not provided");
-        }
-
-        const file = path.join(folder, urlInformation.file);
-        return text_reader(file)()
-    };
-};
-
-const csv_reader = function (file, parameters) {
-    const csvContent = text_reader(file, parameters)();
-    const csvReader = new CSV(csvContent, parameters);
-
-    return csvReader.read.bind(csvReader);
-};
-
-module.exports = {
-    text_reader: text_reader,
-    folder_reader: folder_reader,
-    csv_reader: csv_reader,
-    file_exists: file_exists
+const fs = require('fs');
+const path = require('path');
+const constants = require("./constants");
+const CSV = require('./csv');
+const HttpException = require('./HttpException');
+
+const text_reader = (file) => {
+    return () => {
+        if (!fs.existsSync(file)) {
+            throw new HttpException(constants.HTTP_STATUS_CODES.NOT_FOUND, `File ${file} doesn't exists`);
+        }
+
+        return fs.readFileSync(file, 'utf8');
+    };
+};
+
+const file_exists = (file) => fs.existsSync(file);
+
+const folder_reader = (folder) => {
+    return (urlInformation) => {
+
+        if (!urlInformation.hasFile) {
+            throw new HttpException(constants.HTTP_STATUS_CODES.NOT_ACCEPTABLE, "File not provided");
+        }
+
+        const file = path.join(folder, urlInformation.file);
+        return text_reader(file)()
+    };
+};
+
+const csv_reader = function (file, parameters) {
+    const csvContent = text_reader(file, parameters)();
+    const csvReader = new CSV(csvContent, parameters);
+
+    return csvReader.read.bind(csvReader);
+};
+
+module.exports = {
+    text_reader: text_reader,
+    folder_reader: folder_reader,
+    csv_reader: csv_reader,
+    file_exists: file_exists
 };