ntropi 1.0.0-beta

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
+	};
+}

package/tests/cli_parser.test.js

@@ -0,0 +1,200 @@
+import { describe, it, expect } from 'vitest';
+import { parseArgs } from '../src/libs/cli_parser.js';
+
+describe('CLI Parser', () => {
+	// No args
+	it('Should return default config for no arguments', () => {
+		const args = [];
+		const result = parseArgs(args);
+		expect(result).toEqual({
+			delay: 0,
+			failureRate: 0,
+			config: 'ntropi-config.json',
+			
+		});
+	});
+
+	// Delay only
+	it('Should return delay when --delay is passed', () => {
+		const args = ['--delay', '5'];
+		const result = parseArgs(args);
+		expect(result).toEqual({
+			delay: 5,
+			failureRate: 0,
+			config: 'ntropi-config.json',
+		});
+	});
+});
+
+// Error if delay is negative
+it('Should return error for negative delay', () => {
+	const args = ['--delay', '-3'];
+	const result = parseArgs(args);
+	expect(result).toEqual({ error: 'Delay must be a non-negative integer' });
+});
+
+// Error if delay is not a number
+it('Should return error for non-numeric delay', () => {
+	const args = ['--delay', 'abc'];
+	const result = parseArgs(args);
+	expect(result).toEqual({ error: 'Delay must be a non-negative integer' });
+});
+
+// Failure Rate
+it('Should return failure rate when --failure-rate is passed', () => {
+	const args = ['--failure-rate', '10'];
+	const result = parseArgs(args);
+	expect(result).toEqual({
+		delay: 0,
+		failureRate: 10,
+		config: "ntropi-config.json",
+	});
+});
+
+// Error if failure rate is less than 0 or greater than 1
+it('Should return error for invalid failure rate', () => {
+	const args = ['--failure-rate', '150'];
+	const result = parseArgs(args);
+	expect(result).toEqual({ error: 'Failure rate must be between 0 and 100' });
+});
+
+// Error if failure rate is not a number
+it('Should return error for non-numeric failure rate', () => {
+	const args = ['--failure-rate', 'xyz'];
+	const result = parseArgs(args);
+	expect(result).toEqual({ error: 'Failure rate must be between 0 and 100' });
+});
+
+// Both delay and failure rate
+it('Should return both delay and failure rate when both are passed', () => {
+	const args = ['--delay', '5', '--failure-rate', '10'];
+	const result = parseArgs(args);
+	expect(result).toEqual({
+		delay: 5,
+		failureRate: 10,
+		config: "ntropi-config.json",
+		
+	});
+});
+
+// Config File only
+it('Should return config file when --config is passed', () => {
+	const args = ['--config', 'config.json'];
+	const result = parseArgs(args);
+	expect(result).toEqual({
+		config: 'config.json',
+	});
+});
+
+// Config and Delay
+it('Should return config and delay when both --config and --delay are passed', () => {
+	const args = ['--config', 'config.json', '--delay', '5'];
+	const result = parseArgs(args);
+	expect(result).toEqual({ config: 'config.json', delay: 5});
+});
+
+// Config and Failure Rate
+it('Should return config and failure rate when both --config and --failure-rate are passed', () => {
+	const args = ['--config', 'config.json', '--failure-rate', '10'];
+	const result = parseArgs(args);
+	expect(result).toEqual({ config: 'config.json', failureRate: 10 });
+});
+
+// API only
+it('Should return all APIS after --api flag', () => {
+	const args = ['--api', 'users', 'posts', 'comments'];
+	const result = parseArgs(args);
+	expect(result).toEqual({ config: 'ntropi-config.json', failureRate: 0, delay: 0, apis: ['users', 'posts', 'comments'],  });
+});
+
+
+// All three
+it('Should return config, delay, and failure rate when all are passed', () => {
+	const args = ['--config', 'config.json', '--delay', '5', '--failure-rate', '10'];
+	const result = parseArgs(args);
+	expect(result).toEqual({ config: 'config.json', delay: 5, failureRate: 10 });
+});
+
+// Help flag
+it('Should return help flag when --help is passed', () => {
+	const args = ['--help'];
+	const result = parseArgs(args);
+	expect(result).toEqual({ help: true });
+});
+
+// Bad Arguments
+it("Should throw error for unknown arguments", () => {
+	const args = ['--unknown'];
+	const result = parseArgs(args);
+	expect(result).toEqual({
+		error: `Unknown argument: ${args}`
+	});
+});
+
+// Shorthand tests
+it('Should return delay when -d shorthand is passed', () => {
+	const args = ['-d', '5'];
+	const result = parseArgs(args);
+	expect(result).toEqual({
+		delay: 5,
+		failureRate: 0,
+		config: 'ntropi-config.json',
+	});
+});
+
+it('Should return failure rate when -f shorthand is passed', () => {
+	const args = ['-f', '10'];
+	const result = parseArgs(args);
+	expect(result).toEqual({
+		delay: 0,
+		failureRate: 10,
+		config: "ntropi-config.json",
+	});
+});
+
+it('Should return config file when -c shorthand is passed', () => {
+	const args = ['-c', 'config.json'];
+	const result = parseArgs(args);
+	expect(result).toEqual({
+		config: 'config.json',
+	});
+});
+
+it('Should return all APIs after -a shorthand flag', () => {
+	const args = ['-a', 'users', 'posts', 'comments'];
+	const result = parseArgs(args);
+	expect(result).toEqual({ config: 'ntropi-config.json', failureRate: 0, delay: 0, apis: ['users', 'posts', 'comments'],  });
+});
+
+it('Should work with mixed shorthand and full arguments', () => {
+	const args = ['-c', 'config.json', '--delay', '5', '-f', '10'];
+	const result = parseArgs(args);
+	expect(result).toEqual({ config: 'config.json', delay: 5, failureRate: 10 });
+});
+
+it('Should return all arguments when all shorthands are passed', () => {
+	const args = ['-c', 'config.json', '-d', '5', '-f', '10'];
+	const result = parseArgs(args);
+	expect(result).toEqual({ config: 'config.json', delay: 5, failureRate: 10 });
+});
+
+// Run argument only
+it("should return run and default config file", () => {
+	const args = ['run'];
+	const result = parseArgs(args);
+	expect(result).toEqual({run: true, config: 'ntropi-config.json'});
+});
+
+// Run argument with config file
+it("should return run and user config file", () => {
+	const args = ['run', '--config', 'config.json'];
+	const result = parseArgs(args);
+	expect(result).toEqual({run: true, config: 'config.json'});
+});
+
+// Run argument with config shorthand
+it("should return run and use shorthand config file", () => {
+	const args = ['run', '-c', 'config.json'];
+	const result = parseArgs(args);
+	expect(result).toEqual({run: true, config: 'config.json'});
+});

package/tests/config_genrator.test.js

@@ -0,0 +1,23 @@
+import { describe, it, expect } from "vitest";
+import { generateConfig } from "../src/libs/config_generator";
+import fs from 'fs';
+
+describe('Config Generator', () => {
+	it('should generate config with default values', () => {
+		const result = generateConfig();
+		expect(result).toEqual({ success: true });
+		fs.unlinkSync('ntropi-config.json');
+	});
+
+	it('should generate config with specified delay and failure rate', () => {
+		const result = generateConfig(1000, 10);
+		expect(result).toEqual({ success: true });
+		fs.unlinkSync('ntropi-config.json');
+	});
+	
+	it('should generate config with specified APIs', () => {
+		const result = generateConfig(0, 0, ['users', 'orders']);
+		expect(result).toEqual({ success: true });
+		fs.unlinkSync('ntropi-config.json');
+	});
+});