ntropi 1.0.0-beta.1

package/README.md

@@ -0,0 +1,293 @@
+
+![Ntropi Logo](https://github.com/Pushpender-18/DeLender/blob/main/ntropi-npm-bg.png?raw=true)
+
+<div align="center">
+	<div style="margin-top: 8px;">
+		<strong> 
+			<p>A live mock API generator that works without having any actual backend.
+			Perfect for frontend development, testing, and prototyping.</p>
+		</strong>
+	</div>	
+</div>
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Usage](#usage)
+  - [Basic Commands](#basic-commands)
+  - [Command Options](#command-options)
+- [Configuration File](#configuration-file)
+  - [Endpoint Properties](#endpoint-properties)
+- [Examples](#examples)
+  - [Example 1: Simple API for Frontend Development](#example-1-simple-api-for-frontend-development)
+  - [Example 2: Simulate Slow Network](#example-2-simulate-slow-network)
+  - [Example 3: Test Error Handling](#example-3-test-error-handling)
+  - [Example 4: Multiple Endpoints](#example-4-multiple-endpoints)
+  - [Example 5: Add Endpoints](#example-5-add-endpoints)
+  - [Example 6: Custom Config File](#example-6-custom-config-file)
+  - [Example 7: Complete Workflow](#example-7-complete-workflow)
+- [Advanced Usage](#advanced-usage)
+  - [Custom Response Data](#custom-response-data)
+  - [Testing Different Scenarios](#testing-different-scenarios)
+- [Tips](#tips)
+- [Troubleshooting](#troubleshooting)
+- [Authors](#authors)
+
+## Installation
+
+```bash
+npm install -g ntropi
+```
+
+## Quick Start
+
+Generate a config and run the server:
+
+```bash
+ntropi --api users posts --delay 1000 --failure-rate 10
+ntropi run
+```
+
+## Usage
+
+### Basic Commands
+
+#### Run the Mock Server
+
+```bash
+# Run with default config (ntropi-config.json)
+ntropi run
+
+# Run with custom config file
+ntropi run --config my-config.json
+```
+
+#### Generate Configuration
+
+```bash
+# Generate default config with default settings
+ntropi
+
+# Generate config with specific APIs
+ntropi --api users posts products
+
+# Generate config with delay (in milliseconds)
+ntropi --api users --delay 2000
+
+# Generate config with failure rate (0-100%)
+ntropi --api users --failure-rate 50
+
+# Combine multiple options
+ntropi --api users posts --delay 1000 --failure-rate 25
+```
+
+### Command Options
+
+| Option | Shorthand | Description | Example |
+|--------|-----------|-------------|---------|
+| `--help` | | Show help information | `ntropi --help` |
+| `run` |  | Run the mock server | `ntropi run` |
+| `--api` | `-a` | Specify API endpoints | `ntropi --api users posts` |
+| `--delay` | `-d` | Set response delay (ms) | `ntropi --delay 2000` |
+| `--failure-rate` | `-f` | Set failure rate (0-100%) | `ntropi --failure-rate 30` |
+| `--config` | `-c` | Specify config file | `ntropi --config custom.json` |
+
+## Configuration File
+
+The configuration file (`ntropi-config.json`) defines your mock API endpoints:
+
+```json
+{
+  "endpoints": [
+    {
+      "path": "/api/users",
+      "method": "GET",
+      // If data is an array then one
+      // item is sent at random
+      "data": [
+        {"id": 1, "name": "John Doe"},
+        {"id": 2, "name": "Jane Smith"}
+      ],
+      "delay": 1000,
+      "failureRate": 10
+    },
+    {
+      "path": "/api/posts",
+      "method": "GET",
+      // If data is not an array then
+      // data is sent as it is
+      "data": 
+        {"id": 1, "title": "Hello World"},
+      "delay": 0,
+      "failureRate": 0
+    }
+  ]
+}
+```
+
+**Note:** If data is an array then an item is choosen at random otherwise the data is sent as it is. 
+
+### Endpoint Properties
+
+- **path**: API endpoint path (e.g., `/api/users`)
+- **method**: HTTP method (`GET`, `POST`, `PUT`, `DELETE`, etc.)
+- **data**: Response data (can be any valid JSON)
+- **delay**: Response delay in milliseconds
+- **failureRate**: Percentage chance of returning 500 error (0-100)
+
+## Examples
+
+### Example 1: Simple API for Frontend Development
+
+```bash
+# Create a users API with no delay
+ntropi --api users --delay 0 --failure-rate 0
+ntropi run
+```
+
+Access at: `http://localhost:8008/api/users`
+
+### Example 2: Simulate Slow Network
+
+```bash
+# Create API with 3 second delay
+ntropi --api products --delay 3000
+ntropi run
+```
+
+### Example 3: Test Error Handling
+
+```bash
+# Create API with 50% failure rate
+ntropi --api orders --failure-rate 50
+ntropi run
+```
+
+### Example 4: Multiple Endpoints
+
+```bash
+# Create multiple APIs with different configurations
+ntropi --api users posts comments products
+ntropi run
+```
+
+Then manually edit `ntropi-config.json` to customize each endpoint.
+
+### Example 5: Add Endpoints
+
+```bash
+# Add APIs to existing configuratoin
+ntropi --api users 
+ntropi --api posts 
+ntropi --api comments 
+ntropi --api products
+ntropi run
+```
+
+
+### Example 6: Custom Config File
+
+```bash
+# Use a specific config file
+ntropi run --config staging-api.json
+```
+
+### Example 7: Complete Workflow
+
+```bash
+# 1. Generate config with 3 APIs
+ntropi --api users posts comments --delay 500 --failure-rate 5
+
+# 2. Edit ntropi-config.json to customize responses
+
+# 3. Run the server
+ntropi run
+
+# 4. Access your mock APIs
+# GET http://localhost:8008/api/users
+# GET http://localhost:8008/api/posts
+# GET http://localhost:8008/api/comments
+```
+
+## Advanced Usage
+
+### Custom Response Data
+
+Edit `ntropi-config.json` to add custom response data:
+
+```json
+{
+  "endpoints": [
+    {
+      "path": "/api/users/1",
+      "method": "GET",
+      "data": {
+        "id": 1,
+        "name": "Alice Johnson",
+        "email": "alice@example.com",
+        "role": "admin"
+      },
+      "delay": 500,
+      "failureRate": 0
+    }
+  ]
+}
+```
+
+### Testing Different Scenarios
+
+```json
+{
+  "endpoints": [
+    {
+      "path": "/api/fast-endpoint",
+      "method": "GET",
+      "data": {"message": "Lightning fast!"},
+      "delay": 0,
+      "failureRate": 0
+    },
+    {
+      "path": "/api/slow-endpoint",
+      "method": "GET",
+      "data": {"message": "Taking my time..."},
+      "delay": 5000,
+      "failureRate": 0
+    },
+    {
+      "path": "/api/unreliable-endpoint",
+      "method": "GET",
+      "data": {"message": "Hope I work!"},
+      "delay": 1000,
+      "failureRate": 80
+    }
+  ]
+}
+```
+
+## Tips
+
+1. **Start Simple**: Begin with basic endpoints and add complexity as needed
+2. **Test Error States**: Use `failureRate` to ensure your app handles errors gracefully
+3. **Realistic Delays**: Use delays to simulate real-world network conditions
+4. **Version Control**: Commit your config files to share API mocks with your team
+5. **Multiple Configs**: Use different config files for different testing scenarios
+
+## Troubleshooting
+
+### Port Already in Use
+If port 8008 is busy, Ntropi will automatically try the next available port.
+
+### Config File Not Found
+Make sure you've generated a config file first or specify the correct path with `--config`.
+
+### Syntax Error in Config
+Validate your JSON file using a JSON validator or linter.
+
+## Authors
+
+- [Amitrajeet Konch](https://x.com/amitrajeet7635)
+- [Pushpender Singh](https://x.com/Pushpender20359)
+
+
+

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "ntropi",
+  "version": "1.0.0-beta.1",
+  "description": "A live mock api generator that works without having any actual backend.",
+  "author": "Amitrajeet Konch, Pushpender Singh",
+  "type": "module",
+  "main": "src/app.js",
+  "bin": {
+    "ntropi": "src/app.js"
+  },
+  "scripts": {
+    "test": "vitest"
+  },
+  "dependencies": {
+    "dotenv": "^17.2.3",
+    "fastify": "^5.7.4"
+  },
+  "devDependencies": {
+    "verdaccio": "^6.2.5",
+    "vitest": "^4.0.18"
+  }
+}

package/src/app.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+import { run_server } from './libs/backend.js';
+import { parseArgs } from './libs/cli_parser.js';
+import { updateConfig } from './libs/config_updater.js';
+
+const args = process.argv.slice(2);
+const CONFIG = parseArgs(args);
+
+// Error Handling
+if (CONFIG.error) {
+	console.log(`Error: ${CONFIG.error}`);
+	process.exit(1);
+}
+
+// Help
+if (CONFIG.help) {
+	console.log(`
+Usage: node app.js [options]
+
+Options:
+  --help                        Show help information
+  -a, --api                     Specify API endpoints to generate (e.g., --api users orders products)
+  -d, --delay <num>             Set delay in seconds (non-negative integer)
+  -f, --failure-rate <num>      Set failure rate percentage (0-100)
+  -c, --config <file>           Specify configuration file (default: ntropi-config.json generated)
+  run 				Start the server with the default configuration file (-c for custom config file)
+`);
+	process.exit(0);
+}
+
+if (CONFIG.run) {
+	// Run Server
+	const configPath = CONFIG.config || 'ntropi-config.json';
+	await run_server(configPath);
+} else {
+	updateConfig(CONFIG);
+}

package/src/libs/backend.js

@@ -0,0 +1,171 @@
+import Fastify from "fastify";
+import dotenv from "dotenv";
+import { getConfigStateManager } from "./config_state_management.js";
+
+dotenv.config();
+
+let PORT;
+let currentFastifyInstance = null;
+
+function getEndpointSignature(endpoint) {
+	return `${endpoint.method}:${endpoint.path}`;
+}
+
+function hasEndpointChanges(oldConfig, newConfig) {
+	const oldSignatures = new Set(oldConfig.endpoints.map(getEndpointSignature));
+	const newSignatures = new Set(newConfig.endpoints.map(getEndpointSignature));
+	
+	// Check if any endpoints were added or removed
+	if (oldSignatures.size !== newSignatures.size) {
+		return true;
+	}
+	
+	for (const sig of oldSignatures) {
+		if (!newSignatures.has(sig)) {
+			return true;
+		}
+	}
+	
+	for (const sig of newSignatures) {
+		if (!oldSignatures.has(sig)) {
+			return true;
+		}
+	}
+	
+	return false;
+}
+
+function start_listener(fastify) {
+	fastify.listen({ port: PORT}, function (err, address) {
+		if (err) {
+			PORT = (PORT + 1);
+			if (PORT > 65535) {
+				console.error("No available ports found. Please free up a port and try again.");
+				process.exit(1);
+			}
+			start_listener(fastify);
+		} else {
+			console.log(`Server listening at http://localhost:${PORT}/`);
+			const configManager = getConfigStateManager();
+			const config = configManager.getState();
+			output_endpoint_path(PORT, config);
+		}
+	});
+}
+
+function generate_endpoint_path(fastify, config, configManager) {
+	for (let endpoint of config.endpoints) {
+		fastify.route({
+			method: endpoint.method,
+			url: endpoint.path,
+			handler: async (request, reply) => {
+				// Get latest config state for hot reload support
+				const currentConfig = configManager.getState();
+				const currentEndpoint = currentConfig.endpoints.find(
+					ep => ep.path === endpoint.path && ep.method === endpoint.method
+				);
+				
+				if (!currentEndpoint) {
+					reply.code(404).send({ error: "Endpoint not found in current config" });
+					return;
+				}
+				
+				// Simulate delay with current config value
+				if (currentEndpoint.delay && currentEndpoint.delay > 0) {
+					await new Promise(resolve => setTimeout(resolve, currentEndpoint.delay));
+				}
+				
+				// Simulate failure with current config value
+				if (currentEndpoint.failureRate && Math.random() * 100 < currentEndpoint.failureRate) {
+					reply.code(500).send({ error: "Simulated server error" });
+					return;
+				}
+				
+				if (Array.isArray(currentEndpoint.data)) {
+					currentEndpoint.data = currentEndpoint.data[Math.floor(Math.random() * currentEndpoint.data.length)];
+				}
+				reply.send(currentEndpoint.data);
+			}
+		});
+	}
+}
+
+function output_endpoint_path(PORT, config) {
+	for (let endpoint of config.endpoints) {
+		console.log(`Route: http://localhost:${PORT}${endpoint.path}`);
+	}
+}
+
+export function printNtropi() {
+	console.log(`
+ _   _ _                   _      
+| \\ | | |_ _ __ ___  _ __ (_)    
+|  \\| | __| '__/ _ \\| '_ \\| |    
+| |\\  | |_| | | (_) | |_) | |  _
+|_| \\_|\\__|_|  \\___/| .__/|_| (_)  
+                    |_|       	  
+	`);
+}
+
+export async function run_server(configPath = 'ntropi-config.json') {
+	printNtropi();
+	
+	// Initialize config state manager
+	const configManager = getConfigStateManager(configPath);
+	const initResult = configManager.initialize();
+	
+	if (!initResult.success) {
+		console.error(`Failed to load config: ${initResult.message}`);
+		process.exit(1);
+	}
+	
+	let currentConfig = configManager.getState();
+	
+	// Enable hot reload for automatic config updates
+	configManager.enableHotReload();
+	
+	// Subscribe to config changes for logging and server restart
+	configManager.subscribe((event, state, details) => {
+		if (event === 'updated') {
+			// Check if endpoints were added or removed
+			if (hasEndpointChanges(currentConfig, state)) {
+				console.log('Endpoints added or removed - restarting server...');
+				restartServer(configManager);
+				currentConfig = state;
+			} else {
+				console.log('Config updated - endpoints will use new delay and failure rate values');
+				currentConfig = state;
+			}
+		} else if (event === 'fallback') {
+			console.log('Config update failed - using previous working configuration');
+		}
+	});
+	
+	startServer(configManager);
+}
+
+function startServer(configManager) {
+	const config = configManager.getState();
+	const fastify = Fastify({ logger: false });
+	PORT = Number(process.env.PORT) || 8008;
+
+	generate_endpoint_path(fastify, config, configManager);
+	currentFastifyInstance = fastify;
+	start_listener(fastify);
+}
+
+async function restartServer(configManager) {
+	if (currentFastifyInstance) {
+		try {
+			await currentFastifyInstance.close();
+			console.log('Server stopped');
+		} catch (error) {
+			console.error('Error stopping server:', error);
+		}
+	}
+	
+	// Reset to find next available port if needed
+	PORT = Number(process.env.PORT) || 8008;
+	console.log('Starting server with new configuration...');
+	startServer(configManager);
+}

package/src/libs/cli_parser.js

@@ -0,0 +1,111 @@
+import { updateConfig } from "./config_updater.js";
+
+export function parseArgs(args) {
+	const result = {};
+	
+	for (let i = 0; i < args.length; i++) {
+		let arg = args[i];
+
+		// Handle 'run' command (without dashes)
+		if (arg === 'run') {
+			result.run = true;
+			continue;
+		}
+
+		// Skip if not a flag
+		if (!arg.startsWith('-')) {
+			continue;
+		}
+		
+		// Map shorthand to full argument names
+		const shorthandMap = {
+			'-d': '--delay',
+			'-f': '--failure-rate',
+			'-c': '--config',
+			'-a': '--api',
+			'-r': '--run'
+		};
+		
+		if (shorthandMap[arg]) {
+			arg = shorthandMap[arg];
+		}
+		
+		const validArgs = ['--help', '--delay', '--failure-rate', '--config', "--api", '--run'];
+		if (!validArgs.includes(arg)) {
+			return { error: `Unknown argument: ${args[i]}` };
+		}
+
+		if (arg === '--help') {
+			result.help = true;
+		} else if (arg === '--run') {
+			result.run = true;
+		} else if (arg === '--delay') {
+			const delayValue = args[i + 1];
+			const delayNum = Number(delayValue);
+			
+			if (isNaN(delayNum) || delayNum < 0 || !Number.isInteger(delayNum)) {
+				return { error: 'Delay must be a non-negative integer' };
+			}
+			
+			result.delay = delayNum;
+			i++; 
+		} else if (arg === '--api') {
+			// Collect all values following --api until the next flag or end of args
+			const apiValues = [];
+			let j = i + 1;
+			while (j < args.length && !args[j].startsWith('--')) {
+				apiValues.push(args[j]);
+				j++;
+			}
+			
+			if (apiValues.length === 0) {
+				return { error: 'API argument requires at least one API name' };
+			}
+			
+			result.apis = apiValues;
+			i = j - 1; // Update i to the last processed value
+		} else if (arg === '--failure-rate') {
+			const failureRateValue = args[i + 1];
+			const failureRateNum = Number(failureRateValue);
+			
+			if (isNaN(failureRateNum) || failureRateNum < 0 || failureRateNum > 100) {
+				return { error: 'Failure rate must be between 0 and 100' };
+			}
+			
+			result.failureRate = failureRateNum;
+			i++;
+		} else if (arg === '--config') {
+			result.config = args[i + 1];
+			i++;
+		}
+	}
+
+	if (result.run) {
+		if (result.config) {
+			return result;
+
+		}
+		result.config = 'ntropi-config.json';
+		return result;
+	}
+
+	if (!result.help) {
+		if (!result.config) {
+			result.config = 'ntropi-config.json';
+			if (!result.delay) {
+				result.delay = 0;
+			}
+			if (!result.failureRate) {
+				result.failureRate = 0;
+			} 
+		}
+		else if(result.config) {
+			const response = updateConfig(result);
+			if (response.error) {
+				console.log(`Error: ${response.error}`);
+			}
+		}
+	}
+
+	return result;
+}

package/src/libs/config_generator.js

@@ -0,0 +1,36 @@
+import fs from 'fs';
+
+export function generateConfig(delay=0, failureRate=0, apis=[], configFileName='ntropi-config.json') {
+	let fileConfigurationJSON = {"endpoints": []};
+	if (apis.length == 0) {
+		fileConfigurationJSON["endpoints"].push(
+			{
+					'path': '/api/health_check',
+					"method": "GET",
+					"data": ["OK", "Healthy", "Working Fine", "All Good", "Up and Running"],
+					"delay": delay,
+					"failureRate": failureRate
+				}
+		);
+	} else {
+		for (let api of apis) {
+			fileConfigurationJSON["endpoints"].push(
+				{
+					'path': `/api/${api}`,
+					"method": "GET",
+					"data": [`Response from ${api}`],
+					"delay": delay,
+					"failureRate": failureRate
+				}
+			);
+		}
+	}
+	
+	if (fs.existsSync(configFileName)) {
+		return {error: "CONFIG_ALREADY_EXISTS"};
+	}
+	
+	fs.writeFileSync(configFileName, JSON.stringify(fileConfigurationJSON, null, 2));
+	return {success: true};
+
+}

package/src/libs/config_state_management.js

@@ -0,0 +1,183 @@
+import fs from 'fs';
+import { validateConfig } from './config_validator.js';
+import { updateConfig } from './config_updater.js';
+
+class ConfigStateManager {
+	constructor(configPath = 'ntropi-config.json') {
+		this.configPath = configPath;
+		this.currentState = null;
+		this.lastWorkingState = null;
+		this.fileWatcher = null;
+		this.subscribers = [];
+		this.isInitialized = false;
+	}
+
+	// Initialize the state manager and load initial config
+	initialize() {
+		if (this.isInitialized) {
+			console.warn('Config state manager already initialized');
+			return { success: true, state: this.currentState };
+		}
+
+		const result = this.loadConfig();
+		if (result.success) {
+			this.isInitialized = true;
+			this.lastWorkingState = JSON.parse(JSON.stringify(this.currentState));
+		}
+		
+		return result;
+	}
+
+	// Load and validate config file
+	loadConfig() {
+		try {
+			if (!fs.existsSync(this.configPath)) {
+				console.log('Config file not found, creating default config');
+				updateConfig({ config: this.configPath });
+			}
+
+			const fileContent = fs.readFileSync(this.configPath, 'utf-8');
+			const parsedConfig = JSON.parse(fileContent);
+
+			const validation = validateConfig(parsedConfig);
+			if (!validation.valid) {
+				console.error('Config validation failed:', validation.error);
+				return { 
+					success: false, 
+					error: 'CONFIG_VALIDATION_FAILED',
+					message: 'Config validation failed',
+					validationError: validation.error 
+				};
+			}
+
+			this.currentState = validation.config;
+			return { success: true, state: this.currentState };
+
+		} catch (error) {
+			if (error instanceof SyntaxError) {
+				return { 
+					success: false, 
+					error: 'CONFIG_PARSE_ERROR',
+					message: 'Invalid JSON in config file' 
+				};
+			}
+			return { 
+				success: false, 
+				error: 'CONFIG_LOAD_ERROR',
+				message: error.message 
+			};
+		}
+	}
+
+	// Enable hot reload with file watching
+	enableHotReload() {
+		if (!this.isInitialized) {
+			throw new Error('Config state manager must be initialized before enabling hot reload');
+		}
+
+		if (this.fileWatcher) {
+			console.warn('Hot reload already enabled');
+			return;
+		}
+
+		this.fileWatcher = fs.watch(this.configPath, (eventType) => {
+			if (eventType === 'change') {
+				this.handleConfigChange();
+			}
+		});
+
+		console.log(`Hot reload enabled for ${this.configPath}`);
+	}
+
+	// Handle config file changes
+	handleConfigChange() {
+		console.log('Config file change detected, reloading...');
+		
+		const result = this.loadConfig();
+		
+		if (result.success) {
+			this.lastWorkingState = JSON.parse(JSON.stringify(this.currentState));
+			console.log('Config reloaded successfully');
+			this.notifySubscribers('updated', this.currentState);
+		} else {
+			console.error('Config reload failed, falling back to last working state');
+			this.currentState = this.lastWorkingState;
+			this.notifySubscribers('fallback', this.lastWorkingState, result);
+		}
+	}
+
+	// Subscribe to config changes
+	subscribe(callback) {
+		if (typeof callback !== 'function') {
+			throw new Error('Callback must be a function');
+		}
+		this.subscribers.push(callback);
+		return () => this.unsubscribe(callback);
+	}
+
+	// Unsubscribe from config changes
+	unsubscribe(callback) {
+		this.subscribers = this.subscribers.filter(cb => cb !== callback);
+	}
+
+	// Notify all subscribers of state changes
+	notifySubscribers(event, state, details = null) {
+		this.subscribers.forEach(callback => {
+			try {
+				callback(event, state, details);
+			} catch (error) {
+				console.error('Error in subscriber callback:', error);
+			}
+		});
+	}
+
+	// Get current config state as JSON
+	getState() {
+		if (!this.isInitialized) {
+			return null;
+		}
+		return JSON.parse(JSON.stringify(this.currentState));
+	}
+
+	// Get last working config state as JSON
+	getLastWorkingState() {
+		if (!this.lastWorkingState) {
+			return null;
+		}
+		return JSON.parse(JSON.stringify(this.lastWorkingState));
+	}
+
+	// Disable hot reload
+	disableHotReload() {
+		if (this.fileWatcher) {
+			this.fileWatcher.close();
+			this.fileWatcher = null;
+			console.log('Hot reload disabled');
+		}
+	}
+
+	// Cleanup and shutdown
+	shutdown() {
+		this.disableHotReload();
+		this.subscribers = [];
+		this.isInitialized = false;
+		console.log('Config state manager shutdown complete');
+	}
+}
+
+// Singleton instance
+let configStateManagerInstance = null;
+
+export function getConfigStateManager(configPath = 'ntropi-config.json') {
+	if (!configStateManagerInstance) {
+		configStateManagerInstance = new ConfigStateManager(configPath);
+	}
+	return configStateManagerInstance;
+}
+
+export function resetConfigStateManager() {
+	if (configStateManagerInstance) {
+		configStateManagerInstance.shutdown();
+		configStateManagerInstance = null;
+	}
+}

package/src/libs/config_updater.js

@@ -0,0 +1,56 @@
+import fs from "fs";
+import { validateConfig } from "./config_validator.js";
+import { generateConfig } from "./config_generator.js";
+
+export function updateConfig(configuration_data) {
+	const config_file = configuration_data.config;
+	const delay = configuration_data.delay;
+	const failureRate = configuration_data.failureRate;
+	const apis = configuration_data.apis;
+
+	if (!fs.existsSync(config_file)) {
+		return generateConfig(delay, failureRate, apis, config_file);
+	}
+
+	try {
+		const config_data = fs.readFileSync(config_file, "utf-8");
+		const result = validateConfig(JSON.parse(config_data));
+
+		if (!result.valid) {
+			return {
+				success: false,
+				error: result.error
+			};
+		}
+
+		let updatedConfig = result.config;
+
+		// Append new APIs to existing config
+		for (let api of apis) {
+			// Check if API already exists in config
+			const existingEndpoint = updatedConfig.endpoints.find(endpoint => endpoint.path === `/api/${api}`);
+			if (!existingEndpoint) {
+				updatedConfig.endpoints.push({
+					path: `/api/${api}`,
+					method: "GET",
+					data: [`Response from ${api}`],
+					delay: delay,
+					failureRate: failureRate
+				});
+			}
+		}
+
+		// Write updated config back to file
+		fs.writeFileSync(config_file, JSON.stringify(updatedConfig, null, 2), "utf-8");
+
+		return {
+			success: true
+		};
+
+	} catch (error) {
+		return {
+			success: false,
+			error: "Error reading or parsing config file: " + error.message
+		};
+	}
+}

package/src/libs/config_validator.js

@@ -0,0 +1,109 @@
+export function validateConfig(config) {
+	if (!config || typeof config !== 'object') {
+		return { valid: false, error: 'Config must be a valid JSON object' };
+	}
+
+	if (!config.endpoints) {
+		return { valid: false, error: 'Config must have an "endpoints" property' };
+	}
+
+	if (!Array.isArray(config.endpoints)) {
+		return { valid: false, error: 'Endpoints must be an array' };
+	}
+
+	if (config.endpoints.length === 0) {
+		return { valid: false, error: 'Endpoints array cannot be empty' };
+	}
+
+	const validatedConfig = {
+		endpoints: []
+	};
+
+	for (let i = 0; i < config.endpoints.length; i++) {
+		const endpoint = config.endpoints[i];
+		const validationResult = validateEndpoint(endpoint, i);
+		
+		if (!validationResult.valid) {
+			return validationResult;
+		}
+		
+		validatedConfig.endpoints.push(validationResult.endpoint);
+	}
+
+	return {
+		valid: true,
+		config: validatedConfig
+	};
+}
+
+function validateEndpoint(endpoint, index) {
+	if (!endpoint || typeof endpoint !== 'object') {
+		return { valid: false, error: `Endpoint at index ${index} must be a valid object` };
+	}
+
+	if (!endpoint.path) {
+		return { valid: false, error: `Endpoint at index ${index} is missing required property: path` };
+	}
+
+	if (typeof endpoint.path !== 'string') {
+		return { valid: false, error: `Endpoint at index ${index} has invalid path: must be a string` };
+	}
+
+	if (!endpoint.path.startsWith('/')) {
+		return { valid: false, error: `Endpoint at index ${index} has invalid path: must start with /` };
+	}
+
+	if (!endpoint.method) {
+		return { valid: false, error: `Endpoint at index ${index} is missing required property: method` };
+	}
+
+	if (typeof endpoint.method !== 'string') {
+		return { valid: false, error: `Endpoint at index ${index} has invalid method: must be a string` };
+	}
+
+	const validMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
+	const normalizedMethod = endpoint.method.toUpperCase();
+	
+	if (!validMethods.includes(normalizedMethod)) {
+		return { valid: false, error: `Endpoint at index ${index} has invalid method: ${endpoint.method}` };
+	}
+
+	if (!endpoint.data) {
+		return { valid: false, error: `Endpoint at index ${index} is missing required property: data` };
+	}
+
+	if (!Array.isArray(endpoint.data)) {
+		return { valid: false, error: `Endpoint at index ${index} has invalid data: must be an array` };
+	}
+
+	if (endpoint.data.length === 0) {
+		return { valid: false, error: `Endpoint at index ${index} has invalid data: array cannot be empty` };
+	}
+
+	const validatedEndpoint = {
+		path: endpoint.path,
+		method: normalizedMethod,
+		data: endpoint.data,
+		delay: 0,
+		failureRate: 0
+	};
+
+	if (endpoint.delay !== undefined) {
+		if (typeof endpoint.delay !== 'number' || endpoint.delay < 0) {
+			return { valid: false, error: `Endpoint at index ${index} has invalid delay: delay must be a non-negative number` };
+		}
+		validatedEndpoint.delay = endpoint.delay;
+	}
+
+	if (endpoint.failureRate !== undefined) {
+		if (typeof endpoint.failureRate !== 'number' || endpoint.failureRate < 0 || endpoint.failureRate > 100) {
+			return { valid: false, error: `Endpoint at index ${index} has invalid failureRate: must be between 0 and 100` };
+		}
+		validatedEndpoint.failureRate = endpoint.failureRate;
+	}
+
+	return {
+		valid: true,
+		endpoint: validatedEndpoint
+	};
+}