ntropi 1.0.1-beta → 1.0.3-beta

package/README.md

@@ -1,7 +1,7 @@
-<div align="center">
 
 ![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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ntropi",
-  "version": "1.0.1-beta",
+  "version": "1.0.3-beta",
   "description": "A live mock api generator that works without having any actual backend.",
   "author": "Amitrajeet Konch, Pushpender Singh",
   "type": "module",

package/src/libs/backend.js

@@ -1,171 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,183 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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
-	};
-}