ntropi 1.0.0-beta

package/README.md

@@ -0,0 +1,298 @@
+<div align="center">
+	<a href="https://ntropi.tech/" style="text-decoration: none; color: inherit;">
+		<div style="background: #14181F; color: white;
+			font-family: 'Inter', sans-serif; font-size: 4rem;
+			font-weight: bold; border: 0px; border-radius: 8px;
+			padding: 20px;">
+			Ntropi<strong style="color: red">.</strong>
+		</div> 
+	</a>
+	<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",
+  "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 ${address}`);
+			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};
+
+}