@djodjonx/x32-simulator 0.0.3 → 0.0.5

package/src/domain/services/strategies/NodeDiscoveryStrategy.ts

@@ -1,36 +0,0 @@
-import { OscCommandStrategy } from './OscCommandStrategy';
-import { OscMsg, OscReply, RemoteClient } from '../../models/types';
-import { SchemaRegistry } from '../SchemaRegistry';
-
-/**
- * Handles the /node command for tree traversal/discovery.
- * Returns a list of child nodes for a given path.
- */
-export class NodeDiscoveryStrategy implements OscCommandStrategy {
-    constructor(private schemaRegistry: SchemaRegistry) {}
-
-    canHandle(address: string): boolean {
-        return address === '/node';
-    }
-
-    execute(msg: OscMsg, _source: RemoteClient): OscReply[] {
-        const queryPath = msg.args[0] as string;
-        if (!queryPath) return [];
-
-        const children = new Set<string>();
-        const prefix = queryPath.endsWith('/') ? queryPath : `${queryPath}/`;
-
-        for (const key of this.schemaRegistry.getAllPaths()) {
-            if (key.startsWith(prefix)) {
-                const rest = key.slice(prefix.length);
-                const segment = rest.split('/')[0];
-                if (segment) children.add(segment);
-            }
-        }
-
-        return [{
-            address: '/node',
-            args: [queryPath, ...children]
-        }];
-    }
-}

package/src/domain/services/strategies/OscCommandStrategy.ts

@@ -1,22 +0,0 @@
-import { OscMsg, RemoteClient, OscReply } from '../../models/types';
-
-/**
- * Interface for all OSC command handlers.
- * implementing the Strategy pattern for modular message processing.
- */
-export interface OscCommandStrategy {
-    /**
-     * Determines if this strategy can handle the given address.
-     * @param address - OSC address pattern.
-     * @returns True if the strategy matches.
-     */
-    canHandle(address: string): boolean;
-
-    /**
-     * Processes the message and generates appropriate replies.
-     * @param msg - The input message.
-     * @param source - Client remote info (address and port).
-     * @returns Array of responses to send back.
-     */
-    execute(msg: OscMsg, source: RemoteClient): OscReply[];
-}

package/src/domain/services/strategies/StateAccessStrategy.ts

@@ -1,71 +0,0 @@
-import { OscCommandStrategy } from './OscCommandStrategy';
-import { OscMsg, OscReply, RemoteClient } from '../../models/types';
-import { X32State } from '../../entities/X32State';
-import { SchemaRegistry } from '../SchemaRegistry';
-import { ILogger, LogCategory } from '../../ports/ILogger';
-
-/**
- * General-purpose strategy for reading and writing console parameters.
- * acts as the fallback for any command that matches the schema.
- *
- * LOGIC:
- * - If no arguments: Treats as a QUERY (GET) and returns the current value.
- * - If arguments provided: Treats as an UPDATE (SET) and stores the new value.
- */
-export class StateAccessStrategy implements OscCommandStrategy {
-    /**
-     * Initializes the strategy.
-     * @param state - Current mixer state.
-     * @param logger - Logger instance.
-     * @param schemaRegistry - Registry to validate addresses.
-     */
-    constructor(
-        private state: X32State,
-        private logger: ILogger,
-        private schemaRegistry: SchemaRegistry
-    ) {}
-
-    /** @inheritdoc */
-    public canHandle(address: string): boolean {
-        // This is a catch-all for schema items.
-        return this.schemaRegistry.has(address);
-    }
-
-    /** @inheritdoc */
-    public execute(msg: OscMsg, _source: RemoteClient): OscReply[] {
-        const addr = msg.address;
-        const node = this.schemaRegistry.getNode(addr);
-
-        // 1. GET (Query): If no args provided, client is asking for the value.
-        if (msg.args.length === 0) {
-            const val = this.state.get(addr);
-            if (val !== undefined) {
-                return [{ address: addr, args: [val] }];
-            }
-            return [];
-        }
-
-        // 2. SET (Update): If args provided, client is changing the value.
-        const val = msg.args[0];
-        if (node) {
-            // Type Enforcement using new Node logic
-            if (!node.validate(val)) {
-                this.logger.warn(LogCategory.DISPATCH, `[TYPE ERR] ${addr} expected ${node.type}, got ${typeof val}`);
-                return [];
-            }
-
-            this.state.set(addr, val as number | string);
-            this.logger.debug(LogCategory.STATE, `[SET] ${addr} -> ${val}`);
-
-            // Side Effects: Mute Groups
-            if (addr.startsWith('/config/mute/')) {
-                const groupIdx = parseInt(addr.split('/').pop()!, 10);
-                if (!isNaN(groupIdx)) {
-                    this.state.handleMuteGroupChange(groupIdx, val as number);
-                }
-            }
-        }
-
-        return [];
-    }
-}

package/src/domain/services/strategies/StaticResponseStrategy.ts

@@ -1,42 +0,0 @@
-import { OscCommandStrategy } from './OscCommandStrategy';
-import { OscMsg, OscReply, RemoteClient } from '../../models/types';
-import { StaticResponseService } from '../StaticResponseService';
-
-/**
- * Handles discovery and static information queries.
- * e.g., /status, /xinfo, /-prefs/...
- */
-export class StaticResponseStrategy implements OscCommandStrategy {
-    constructor(
-        private serverIp: string,
-        private serverName: string,
-        private serverModel: string,
-        private staticResponseService: StaticResponseService
-    ) {}
-
-    canHandle(address: string): boolean {
-        return !!this.staticResponseService.getResponse(address);
-    }
-
-    execute(msg: OscMsg, _source: RemoteClient): OscReply[] {
-        const rawResponse = this.staticResponseService.getResponse(msg.address);
-
-        if (!rawResponse) return [];
-
-        // Replace template variables
-        const args = rawResponse.map(arg => {
-            if (typeof arg === 'string') {
-                return arg
-                    .replace('{{ip}}', this.serverIp)
-                    .replace('{{name}}', this.serverName)
-                    .replace('{{model}}', this.serverModel);
-            }
-            return arg;
-        });
-
-        return [{
-            address: msg.address,
-            args
-        }];
-    }
-}

package/src/domain/services/strategies/SubscriptionStrategy.ts

@@ -1,56 +0,0 @@
-import { OscCommandStrategy } from './OscCommandStrategy';
-import { OscMsg, RemoteClient, OscReply } from '../../models/types';
-import { SubscriptionManager } from '../../entities/SubscriptionManager';
-import { X32State } from '../../entities/X32State';
-import { ILogger, LogCategory } from '../../ports/ILogger';
-
-export class SubscriptionStrategy implements OscCommandStrategy {
-    constructor(
-        private subscriptionManager: SubscriptionManager,
-        private state: X32State,
-        private logger: ILogger
-    ) {}
-
-    canHandle(address: string): boolean {
-        return ['/subscribe', '/renew', '/unsubscribe', '/xremote'].includes(address);
-    }
-
-    /**
-     * Handles Session and Subscription lifecycle.
-     *
-     * ROUTES:
-     * - /xremote: Firehose subscription (requests all console updates for 10s).
-     * - /subscribe [path]: Requests updates for a specific node path for 10s.
-     * - /renew [path]: Resets the 10s watchdog timer for a path.
-     * - /unsubscribe [path]: Stops updates for a path.
-     * @param msg - Parsed OSC message.
-     * @param source - Source address and port of the packet.
-     * @returns Returns the current value of the path upon subscription.
-     */
-    execute(msg: OscMsg, source: RemoteClient): OscReply[] {
-        const addr = msg.address;
-
-        if (addr === '/xremote') {
-            this.subscriptionManager.addPathSubscriber(source, '/xremote');
-            return [{ address: '/xremote', args: [] }];
-        }
-
-        if (addr === '/unsubscribe') {
-            this.subscriptionManager.removeSubscriber(source, msg.args[0] as string);
-            this.logger.debug(LogCategory.SUB, `[UNSUB] ${msg.args[0]}`);
-            return [];
-        }
-
-        // Subscribe / Renew
-        const target = msg.args[0] as string;
-        this.subscriptionManager.addPathSubscriber(source, target);
-        const val = this.state.get(target);
-
-        if (val !== undefined) {
-            this.logger.debug(LogCategory.SUB, `[SUB] ${target} -> ${val}`);
-            return [{ address: target, args: [val] }];
-        }
-
-        return [];
-    }
-}

package/src/infrastructure/mappers/OscCodec.ts

@@ -1,54 +0,0 @@
-import { Message, decode, encode } from 'node-osc';
-import { OscPacket, OscArgument } from '../../domain/models/types';
-import { SchemaRegistry } from '../../domain/services/SchemaRegistry';
-
-/**
- * Handles encoding and decoding of X32 OSC messages.
- */
-export class OscCodec {
-
-  constructor(private schemaRegistry: SchemaRegistry) {}
-
-  /**
-   * Decodes a binary OSC message into a packet object.
-   * @param msg - Raw UDP buffer.
-   * @returns Decoded OscPacket.
-   */
-  public decode(msg: Buffer): OscPacket {
-      return decode(msg) as OscPacket;
-  }
-
-  /**
-   * Encodes an address and arguments into a binary OSC message.
-   * @param address - OSC address pattern.
-   * @param args - Array of arguments.
-   * @returns Binary buffer.
-   */
-  public encode(address: string, args: OscArgument[]): Buffer {
-      const msg = this.createMessage(address, args);
-      return encode(msg);
-  }
-
-  /**
-   * Creates a typed node-osc Message based on X32 schema.
-   * @param address - Target address.
-   * @param args - Untyped arguments.
-   * @returns Typed Message.
-   */
-  private createMessage(address: string, args: OscArgument[]): Message {
-    // Enforce types based on schema if possible
-    const typedArgs = args.map((arg: OscArgument) => {
-        if (typeof arg === 'object' && arg !== null && 'type' in arg && 'value' in arg) return arg;
-        if (Buffer.isBuffer(arg)) return arg;
-
-        const node = this.schemaRegistry.getNode(address);
-        if (node) {
-            if (node.type === 'f' && typeof arg === 'number') return { type: 'f', value: arg };
-            if (node.type === 'i' && typeof arg === 'number') return { type: 'i', value: Math.round(arg) };
-            if (node.type === 's' && typeof arg === 'string') return { type: 's', value: arg };
-        }
-        return arg;
-    });
-    return new Message(address, ...typedArgs);
-  }
-}

package/src/infrastructure/repositories/InMemoryStateRepository.ts

@@ -1,37 +0,0 @@
-import { IStateRepository } from '../../domain/ports/IStateRepository';
-import { X32State } from '../../domain/entities/X32State';
-import { ILogger, LogCategory } from '../../domain/ports/ILogger';
-import { SchemaRegistry } from '../../domain/services/SchemaRegistry';
-
-/**
- * In-memory implementation of the state repository.
- * Stores the mixer state in volatile memory during the simulator's execution.
- */
-export class InMemoryStateRepository implements IStateRepository {
-    private state: X32State;
-
-    /**
-     * Creates a new InMemoryStateRepository.
-     * @param logger - Logger service.
-     * @param schemaRegistry - Registry providing the initial state schema.
-     */
-    constructor(private logger: ILogger, schemaRegistry: SchemaRegistry) {
-        this.state = new X32State(schemaRegistry.getSchema());
-    }
-
-    /**
-     * Returns the current mixer state instance.
-     * @returns The X32State entity.
-     */
-    public getState(): X32State {
-        return this.state;
-    }
-
-    /**
-     * Resets the entire state to its default values.
-     */
-    public reset(): void {
-        this.logger.info(LogCategory.SYSTEM, 'Resetting state to defaults');
-        this.state.reset();
-    }
-}

package/src/infrastructure/services/ConsoleLogger.ts

@@ -1,177 +0,0 @@
-import { ILogger, LogCategory, LogData } from '../../domain/ports/ILogger';
-
-/**
- * Log levels for the application.
- */
-export enum LogLevel {
-    DEBUG = 0,
-    INFO = 1,
-    WARN = 2,
-    ERROR = 3,
-    NONE = 4
-}
-
-/**
- * Enhanced logger with category support and environment-based filtering.
- */
-export class ConsoleLogger implements ILogger {
-    private static instance: ConsoleLogger;
-    private level: LogLevel = LogLevel.DEBUG;
-    private hiddenPatterns: string[] = [];
-    private enabledCategories: Set<string> = new Set([
-        LogCategory.SYSTEM,
-        LogCategory.OSC_IN,
-        LogCategory.OSC_OUT,
-        LogCategory.DISPATCH,
-        LogCategory.STATE,
-        LogCategory.SUB,
-    ]);
-
-    constructor() {
-        if (process.env.HIDDEN_LOG) {
-            this.hiddenPatterns = process.env.HIDDEN_LOG.split(',').map(s => s.trim()).filter(s => s.length > 0);
-        }
-    }
-
-    /**
-     * Gets the singleton instance.
-     * @returns ConsoleLogger instance.
-     */
-    public static getInstance(): ConsoleLogger {
-        if (!ConsoleLogger.instance) {
-            ConsoleLogger.instance = new ConsoleLogger();
-        }
-        return ConsoleLogger.instance;
-    }
-
-    /**
-     * Sets the minimum log level.
-     * @param level - LogLevel.
-     */
-    public setLevel(level: LogLevel) {
-        this.level = level;
-    }
-
-    /**
-     * Enables a category for output.
-     * @param cat - Category name.
-     */
-    public enableCategory(cat: string) {
-        this.enabledCategories.add(cat);
-    }
-
-    /**
-     * Disables a category for output.
-     * @param cat - Category name.
-     */
-    public disableCategory(cat: string) {
-        this.enabledCategories.delete(cat);
-    }
-
-    /**
-     * Logs a debug message.
-     * @param category - Log category.
-     * @param msg - Message string.
-     * @param data - Optional metadata.
-     */
-    public debug(category: string, msg: string, data?: LogData) {
-        if (this.shouldHide(msg, data)) return;
-        if (this.level <= LogLevel.DEBUG && this.enabledCategories.has(category)) {
-            console.log(this.format('DEBUG', category, msg, data));
-        }
-    }
-
-    /**
-     * Logs an info message.
-     * @param category - Log category.
-     * @param msg - Message string.
-     * @param data - Optional metadata.
-     */
-    public info(category: string, msg: string, data?: LogData) {
-        if (this.shouldHide(msg, data)) return;
-        if (this.level <= LogLevel.INFO && this.enabledCategories.has(category)) {
-            console.log(this.format('INFO ', category, msg, data));
-        }
-    }
-
-    /**
-     * Logs a warning message.
-     * @param category - Log category.
-     * @param msg - Message string.
-     * @param data - Optional metadata.
-     */
-    public warn(category: string, msg: string, data?: LogData) {
-        if (this.shouldHide(msg, data)) return;
-        if (this.level <= LogLevel.WARN && this.enabledCategories.has(category)) {
-            console.log(this.format('WARN ', category, msg, data));
-        }
-    }
-
-    /**
-     * Logs an error message.
-     * @param category - Log category.
-     * @param msg - Message string.
-     * @param err - Optional error object.
-     */
-    public error(category: string, msg: string, err?: LogData) {
-        if (this.shouldHide(msg, err)) return;
-        if (this.level <= LogLevel.ERROR) {
-            console.log(this.format('ERROR', category, msg, err));
-        }
-    }
-
-    /**
-     * Checks if a log should be hidden based on patterns.
-     * @param msg - Message.
-     * @param data - Metadata.
-     * @returns True if log should be suppressed.
-     */
-    private shouldHide(msg: string, data?: LogData): boolean {
-        if (this.hiddenPatterns.length === 0) return false;
-        if (this.hiddenPatterns.some(p => msg.includes(p))) return true;
-        if (data !== undefined) {
-            const strData = Buffer.isBuffer(data) ? data.toString('hex') : (typeof data === 'object' ? JSON.stringify(data) : String(data));
-            if (this.hiddenPatterns.some(p => strData.includes(p))) return true;
-        }
-        return false;
-    }
-
-    /**
-     * Formats the log message.
-     * @param level - Level label.
-     * @param category - Category label.
-     * @param msg - Message.
-     * @param data - Metadata.
-     * @returns Formatted string.
-     */
-    private format(level: string, category: string, msg: string, data?: LogData): string {
-        const now = new Date();
-        const time = `${now.getHours().toString().padStart(2,'0')}:${now.getMinutes().toString().padStart(2,'0')}:${now.getSeconds().toString().padStart(2,'0')}.${now.getMilliseconds().toString().padStart(3,'0')}`;
-        
-        let out = `\x1b[90m[${time}]\x1b[0m `; // Gray timestamp
-        
-        switch(level) {
-            case 'DEBUG': out += `\x1b[36m[DEBUG]\x1b[0m`; break; 
-            case 'INFO ': out += `\x1b[32m[INFO ]\x1b[0m`; break; 
-            case 'WARN ': out += `\x1b[33m[WARN ]\x1b[0m`; break; 
-            case 'ERROR': out += `\x1b[31m[ERROR]\x1b[0m`; break; 
-        }
-
-        out += ` \x1b[35m[${category.padEnd(8)}]\x1b[0m ${msg}`;
-
-        if (data !== undefined) {
-            try {
-                if (Buffer.isBuffer(data)) {
-                    out += ` \x1b[90m<Buffer ${data.length}b>\x1b[0m`;
-                } else if (typeof data === 'object' && data !== null) {
-                    out += ` \x1b[90m${JSON.stringify(data)}\x1b[0m`;
-                } else {
-                    out += ` \x1b[90m${data}\x1b[0m`;
-                }
-            } catch {
-                out += ` [Circular/Error]`;
-            }
-        }
-        return out;
-    }
-}

package/src/infrastructure/services/UdpNetworkGateway.ts

@@ -1,100 +0,0 @@
-import * as dgram from 'node:dgram';
-import { INetworkGateway } from '../../domain/ports/INetworkGateway';
-import { OscPacket, RemoteClient } from '../../domain/models/types';
-import { OscCodec } from '../mappers/OscCodec';
-import { ILogger, LogCategory } from '../../domain/ports/ILogger';
-
-/**
- * Node.js UDP implementation of the network gateway.
- * Handles the low-level socket communication and OSC packet routing.
- */
-export class UdpNetworkGateway implements INetworkGateway {
-    private socket: dgram.Socket;
-    private isRunning = false;
-    private packetCallback: ((packet: OscPacket, source: RemoteClient) => void) | null = null;
-
-    /**
-     * Creates a new UdpNetworkGateway.
-     * @param logger - Logger service.
-     * @param codec - OSC codec for encoding/decoding.
-     */
-    constructor(private logger: ILogger, private codec: OscCodec) {
-        this.socket = dgram.createSocket('udp4');
-    }
-
-    /**
-     * Registers a callback to be executed whenever a new OSC packet arrives.
-     * @param callback - Function called with decoded packet and source info.
-     */
-    public onPacket(callback: (packet: OscPacket, source: RemoteClient) => void): void {
-        this.packetCallback = callback;
-    }
-
-    /**
-     * Starts the UDP server on the specified port and IP.
-     * @param port - UDP port.
-     * @param ip - IP address to bind to.
-     * @returns Promise resolving when the socket is bound.
-     */
-    public start(port: number, ip: string): Promise<void> {
-        return new Promise((resolve, reject) => {
-            this.socket.on('error', (err) => {
-                this.logger.error(LogCategory.SYSTEM, 'Socket Error', err);
-                reject(err);
-            });
-
-            this.socket.on('message', (msg, rinfo) => {
-                try {
-                    this.logger.debug(LogCategory.OSC_IN, `Packet received ${msg.length}b`, { ip: rinfo.address });
-                    const decoded = this.codec.decode(msg);
-                    if (this.packetCallback) {
-                        this.packetCallback(decoded, { address: rinfo.address, port: rinfo.port });
-                    }
-                } catch (err) {
-                    this.logger.error(LogCategory.OSC_IN, 'Decode Error', err instanceof Error ? err : new Error(String(err)));
-                }
-            });
-
-            this.socket.bind(port, ip, () => {
-                this.logger.info(LogCategory.SYSTEM, `Server bound to ${ip}:${port}`);
-                this.isRunning = true;
-                resolve();
-            });
-        });
-    }
-
-    /**
-     * Shuts down the UDP server.
-     * @returns Promise resolving when the socket is closed.
-     */
-    public stop(): Promise<void> {
-        return new Promise((resolve) => {
-            if (!this.isRunning) return resolve();
-            this.socket.close(() => {
-                this.isRunning = false;
-                this.logger.info(LogCategory.SYSTEM, 'Server stopped');
-                resolve();
-            });
-        });
-    }
-
-    /**
-     * Sends an OSC message to a specific remote client.
-     * @param target - Target client info (IP/port).
-     * @param address - OSC address pattern.
-     * @param args - Array of arguments.
-     */
-    public send(target: RemoteClient, address: string, args: any[]): void {
-        const buf = this.codec.encode(address, args);
-        const cat = address.startsWith('/meters') ? LogCategory.METER : LogCategory.OSC_OUT;
-
-        // Skip noisy meter logging if needed, or rely on logger level
-        this.logger.debug(cat, `Sending ${address}`, { ip: target.address, args });
-
-        this.socket.send(buf, target.port, target.address, (err) => {
-            if (err) {
-                this.logger.error(LogCategory.OSC_OUT, 'Send Error', err);
-            }
-        });
-    }
-}