@superdangerous/app-framework 4.9.0

package/dist/services/websocketEvents.d.ts

@@ -0,0 +1,372 @@
+/**
+ * WebSocket Event System
+ * Standardized event patterns for real-time communication
+ */
+import { Server as SocketIOServer, Socket } from "socket.io";
+/**
+ * Standard event types
+ */
+export declare enum EventTypes {
+    CONNECT = "connect",
+    DISCONNECT = "disconnect",
+    ERROR = "error",
+    DATA_UPDATE = "data:update",
+    DATA_CREATE = "data:create",
+    DATA_DELETE = "data:delete",
+    DATA_SYNC = "data:sync",
+    STATUS_CHANGE = "status:change",
+    STATUS_HEALTH = "status:health",
+    STATUS_METRICS = "status:metrics",
+    CONTROL_START = "control:start",
+    CONTROL_STOP = "control:stop",
+    CONTROL_RESTART = "control:restart",
+    CONTROL_CONFIG = "control:config",
+    SUBSCRIBE = "subscribe",
+    UNSUBSCRIBE = "unsubscribe",
+    SYSTEM_PING = "system:ping",
+    SYSTEM_PONG = "system:pong",
+    SYSTEM_INFO = "system:info",
+    SYSTEM_ALERT = "system:alert"
+}
+/**
+ * Standard event payload structure
+ */
+export interface EventPayload<T = any> {
+    id?: string;
+    timestamp: string;
+    type: string;
+    source?: string;
+    target?: string;
+    data: T;
+    metadata?: Record<string, any>;
+}
+/**
+ * Event response structure
+ */
+export interface EventResponse<T = any> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    timestamp: string;
+}
+/**
+ * WebSocket Event Manager
+ */
+export declare class WebSocketEventManager {
+    private io;
+    private subscriptions;
+    private eventHandlers;
+    constructor(io: SocketIOServer);
+    /**
+     * Setup default event handlers
+     */
+    private setupDefaultHandlers;
+    /**
+     * Subscribe socket to a channel
+     */
+    subscribe(socket: Socket, channel: string): void;
+    /**
+     * Unsubscribe socket from a channel
+     */
+    unsubscribe(socket: Socket, channel: string): void;
+    /**
+     * Clean up all subscriptions for a socket
+     */
+    private cleanupSubscriptions;
+    /**
+     * Emit event to all clients
+     */
+    broadcast<T>(event: string, payload: EventPayload<T>): void;
+    /**
+     * Emit event to specific room/channel
+     */
+    emit<T>(channel: string, event: string, payload: EventPayload<T>): void;
+    /**
+     * Send event to specific socket
+     */
+    send<T>(socketId: string, event: string, payload: EventPayload<T>): void;
+    /**
+     * Register custom event handler
+     */
+    on(event: string, handler: (socket: Socket, data: any) => void): void;
+    /**
+     * Get subscription statistics
+     */
+    getStats(): {
+        connections: number;
+        channels: number;
+        subscriptions: Record<string, number>;
+    };
+}
+/**
+ * Typed event emitter for specific domains
+ */
+export declare class TypedEventEmitter<T extends Record<string, any>> {
+    private manager;
+    private namespace;
+    constructor(manager: WebSocketEventManager, namespace: string);
+    /**
+     * Emit typed event
+     */
+    emit<K extends keyof T>(event: K, data: T[K]): void;
+    /**
+     * Emit to specific channel
+     */
+    emitTo<K extends keyof T>(channel: string, event: K, data: T[K]): void;
+}
+/**
+ * Create event patterns for common use cases
+ */
+export declare const EventPatterns: {
+    /**
+     * CRUD event pattern
+     */
+    crud: <T>(namespace: string) => {
+        created: (data: T) => {
+            event: string;
+            payload: {
+                timestamp: string;
+                type: string;
+                data: T;
+            };
+        };
+        updated: (data: T) => {
+            event: string;
+            payload: {
+                timestamp: string;
+                type: string;
+                data: T;
+            };
+        };
+        deleted: (id: string) => {
+            event: string;
+            payload: {
+                timestamp: string;
+                type: string;
+                data: {
+                    id: string;
+                };
+            };
+        };
+        list: (data: T[]) => {
+            event: string;
+            payload: {
+                timestamp: string;
+                type: string;
+                data: T[];
+            };
+        };
+    };
+    /**
+     * Status event pattern
+     */
+    status: (namespace: string) => {
+        online: () => {
+            event: string;
+            payload: {
+                timestamp: string;
+                type: string;
+                data: {
+                    status: string;
+                };
+            };
+        };
+        offline: () => {
+            event: string;
+            payload: {
+                timestamp: string;
+                type: string;
+                data: {
+                    status: string;
+                };
+            };
+        };
+        error: (error: string) => {
+            event: string;
+            payload: {
+                timestamp: string;
+                type: string;
+                data: {
+                    error: string;
+                };
+            };
+        };
+        health: (health: any) => {
+            event: string;
+            payload: {
+                timestamp: string;
+                type: string;
+                data: any;
+            };
+        };
+    };
+    /**
+     * Data stream pattern
+     */
+    stream: <T>(namespace: string) => {
+        start: () => {
+            event: string;
+            payload: {
+                timestamp: string;
+                type: string;
+                data: {};
+            };
+        };
+        data: (data: T) => {
+            event: string;
+            payload: {
+                timestamp: string;
+                type: string;
+                data: T;
+            };
+        };
+        end: () => {
+            event: string;
+            payload: {
+                timestamp: string;
+                type: string;
+                data: {};
+            };
+        };
+        error: (error: string) => {
+            event: string;
+            payload: {
+                timestamp: string;
+                type: string;
+                data: {
+                    error: string;
+                };
+            };
+        };
+    };
+};
+declare const _default: {
+    WebSocketEventManager: typeof WebSocketEventManager;
+    TypedEventEmitter: typeof TypedEventEmitter;
+    EventTypes: typeof EventTypes;
+    EventPatterns: {
+        /**
+         * CRUD event pattern
+         */
+        crud: <T>(namespace: string) => {
+            created: (data: T) => {
+                event: string;
+                payload: {
+                    timestamp: string;
+                    type: string;
+                    data: T;
+                };
+            };
+            updated: (data: T) => {
+                event: string;
+                payload: {
+                    timestamp: string;
+                    type: string;
+                    data: T;
+                };
+            };
+            deleted: (id: string) => {
+                event: string;
+                payload: {
+                    timestamp: string;
+                    type: string;
+                    data: {
+                        id: string;
+                    };
+                };
+            };
+            list: (data: T[]) => {
+                event: string;
+                payload: {
+                    timestamp: string;
+                    type: string;
+                    data: T[];
+                };
+            };
+        };
+        /**
+         * Status event pattern
+         */
+        status: (namespace: string) => {
+            online: () => {
+                event: string;
+                payload: {
+                    timestamp: string;
+                    type: string;
+                    data: {
+                        status: string;
+                    };
+                };
+            };
+            offline: () => {
+                event: string;
+                payload: {
+                    timestamp: string;
+                    type: string;
+                    data: {
+                        status: string;
+                    };
+                };
+            };
+            error: (error: string) => {
+                event: string;
+                payload: {
+                    timestamp: string;
+                    type: string;
+                    data: {
+                        error: string;
+                    };
+                };
+            };
+            health: (health: any) => {
+                event: string;
+                payload: {
+                    timestamp: string;
+                    type: string;
+                    data: any;
+                };
+            };
+        };
+        /**
+         * Data stream pattern
+         */
+        stream: <T>(namespace: string) => {
+            start: () => {
+                event: string;
+                payload: {
+                    timestamp: string;
+                    type: string;
+                    data: {};
+                };
+            };
+            data: (data: T) => {
+                event: string;
+                payload: {
+                    timestamp: string;
+                    type: string;
+                    data: T;
+                };
+            };
+            end: () => {
+                event: string;
+                payload: {
+                    timestamp: string;
+                    type: string;
+                    data: {};
+                };
+            };
+            error: (error: string) => {
+                event: string;
+                payload: {
+                    timestamp: string;
+                    type: string;
+                    data: {
+                        error: string;
+                    };
+                };
+            };
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=websocketEvents.d.ts.map

package/dist/services/websocketEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocketEvents.d.ts","sourceRoot":"","sources":["../../src/services/websocketEvents.ts"],"names":[],"mappings":"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"}

package/dist/services/websocketEvents.js

@@ -0,0 +1,338 @@
+/**
+ * WebSocket Event System
+ * Standardized event patterns for real-time communication
+ */
+import { createLogger } from "../core/index.js";
+let logger; // Will be initialized when needed
+function ensureLogger() {
+    if (!logger) {
+        logger = createLogger("WebSocketEvents");
+    }
+    return logger;
+}
+/**
+ * Standard event types
+ */
+export var EventTypes;
+(function (EventTypes) {
+    // Connection events
+    EventTypes["CONNECT"] = "connect";
+    EventTypes["DISCONNECT"] = "disconnect";
+    EventTypes["ERROR"] = "error";
+    // Data events
+    EventTypes["DATA_UPDATE"] = "data:update";
+    EventTypes["DATA_CREATE"] = "data:create";
+    EventTypes["DATA_DELETE"] = "data:delete";
+    EventTypes["DATA_SYNC"] = "data:sync";
+    // Status events
+    EventTypes["STATUS_CHANGE"] = "status:change";
+    EventTypes["STATUS_HEALTH"] = "status:health";
+    EventTypes["STATUS_METRICS"] = "status:metrics";
+    // Control events
+    EventTypes["CONTROL_START"] = "control:start";
+    EventTypes["CONTROL_STOP"] = "control:stop";
+    EventTypes["CONTROL_RESTART"] = "control:restart";
+    EventTypes["CONTROL_CONFIG"] = "control:config";
+    // Subscription events
+    EventTypes["SUBSCRIBE"] = "subscribe";
+    EventTypes["UNSUBSCRIBE"] = "unsubscribe";
+    // System events
+    EventTypes["SYSTEM_PING"] = "system:ping";
+    EventTypes["SYSTEM_PONG"] = "system:pong";
+    EventTypes["SYSTEM_INFO"] = "system:info";
+    EventTypes["SYSTEM_ALERT"] = "system:alert";
+})(EventTypes || (EventTypes = {}));
+/**
+ * WebSocket Event Manager
+ */
+export class WebSocketEventManager {
+    io;
+    subscriptions = new Map();
+    eventHandlers = new Map();
+    constructor(io) {
+        this.io = io;
+        this.setupDefaultHandlers();
+    }
+    /**
+     * Setup default event handlers
+     */
+    setupDefaultHandlers() {
+        this.io.on("connection", (socket) => {
+            ensureLogger().info(`Client connected: ${socket.id}`);
+            // Handle ping/pong for keepalive
+            socket.on(EventTypes.SYSTEM_PING, () => {
+                socket.emit(EventTypes.SYSTEM_PONG, {
+                    timestamp: new Date().toISOString(),
+                    latency: 0,
+                });
+            });
+            // Handle subscriptions
+            socket.on(EventTypes.SUBSCRIBE, (channel) => {
+                this.subscribe(socket, channel);
+            });
+            socket.on(EventTypes.UNSUBSCRIBE, (channel) => {
+                this.unsubscribe(socket, channel);
+            });
+            // Handle disconnect
+            socket.on(EventTypes.DISCONNECT, () => {
+                ensureLogger().info(`Client disconnected: ${socket.id}`);
+                this.cleanupSubscriptions(socket.id);
+            });
+            // Send initial connection info
+            socket.emit(EventTypes.SYSTEM_INFO, {
+                id: socket.id,
+                timestamp: new Date().toISOString(),
+                server: "framework-websocket",
+                version: "1.0.0",
+            });
+        });
+    }
+    /**
+     * Subscribe socket to a channel
+     */
+    subscribe(socket, channel) {
+        socket.join(channel);
+        if (!this.subscriptions.has(channel)) {
+            this.subscriptions.set(channel, new Set());
+        }
+        this.subscriptions.get(channel).add(socket.id);
+        ensureLogger().debug(`Socket ${socket.id} subscribed to ${channel}`);
+        socket.emit(EventTypes.SUBSCRIBE, {
+            success: true,
+            channel,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    /**
+     * Unsubscribe socket from a channel
+     */
+    unsubscribe(socket, channel) {
+        socket.leave(channel);
+        const subs = this.subscriptions.get(channel);
+        if (subs) {
+            subs.delete(socket.id);
+            if (subs.size === 0) {
+                this.subscriptions.delete(channel);
+            }
+        }
+        ensureLogger().debug(`Socket ${socket.id} unsubscribed from ${channel}`);
+        socket.emit(EventTypes.UNSUBSCRIBE, {
+            success: true,
+            channel,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    /**
+     * Clean up all subscriptions for a socket
+     */
+    cleanupSubscriptions(socketId) {
+        for (const [channel, subs] of this.subscriptions.entries()) {
+            if (subs.has(socketId)) {
+                subs.delete(socketId);
+                if (subs.size === 0) {
+                    this.subscriptions.delete(channel);
+                }
+            }
+        }
+    }
+    /**
+     * Emit event to all clients
+     */
+    broadcast(event, payload) {
+        this.io.emit(event, payload);
+        ensureLogger().debug(`Broadcast event: ${event}`);
+    }
+    /**
+     * Emit event to specific room/channel
+     */
+    emit(channel, event, payload) {
+        this.io.to(channel).emit(event, payload);
+        ensureLogger().debug(`Emit to ${channel}: ${event}`);
+    }
+    /**
+     * Send event to specific socket
+     */
+    send(socketId, event, payload) {
+        this.io.to(socketId).emit(event, payload);
+        ensureLogger().debug(`Send to ${socketId}: ${event}`);
+    }
+    /**
+     * Register custom event handler
+     */
+    on(event, handler) {
+        if (!this.eventHandlers.has(event)) {
+            this.eventHandlers.set(event, new Set());
+            // Register with socket.io
+            this.io.on("connection", (socket) => {
+                socket.on(event, (data) => {
+                    const handlers = this.eventHandlers.get(event);
+                    if (handlers) {
+                        handlers.forEach((h) => h(socket, data));
+                    }
+                });
+            });
+        }
+        this.eventHandlers.get(event).add(handler);
+    }
+    /**
+     * Get subscription statistics
+     */
+    getStats() {
+        const stats = {
+            connections: this.io.sockets.sockets.size,
+            channels: this.subscriptions.size,
+            subscriptions: {},
+        };
+        for (const [channel, subs] of this.subscriptions.entries()) {
+            stats.subscriptions[channel] = subs.size;
+        }
+        return stats;
+    }
+}
+/**
+ * Typed event emitter for specific domains
+ */
+export class TypedEventEmitter {
+    manager;
+    namespace;
+    constructor(manager, namespace) {
+        this.manager = manager;
+        this.namespace = namespace;
+    }
+    /**
+     * Emit typed event
+     */
+    emit(event, data) {
+        const payload = {
+            timestamp: new Date().toISOString(),
+            type: String(event),
+            source: this.namespace,
+            data,
+        };
+        this.manager.broadcast(`${this.namespace}:${String(event)}`, payload);
+    }
+    /**
+     * Emit to specific channel
+     */
+    emitTo(channel, event, data) {
+        const payload = {
+            timestamp: new Date().toISOString(),
+            type: String(event),
+            source: this.namespace,
+            target: channel,
+            data,
+        };
+        this.manager.emit(channel, `${this.namespace}:${String(event)}`, payload);
+    }
+}
+/**
+ * Create event patterns for common use cases
+ */
+export const EventPatterns = {
+    /**
+     * CRUD event pattern
+     */
+    crud: (namespace) => ({
+        created: (data) => ({
+            event: `${namespace}:created`,
+            payload: { timestamp: new Date().toISOString(), type: "created", data },
+        }),
+        updated: (data) => ({
+            event: `${namespace}:updated`,
+            payload: { timestamp: new Date().toISOString(), type: "updated", data },
+        }),
+        deleted: (id) => ({
+            event: `${namespace}:deleted`,
+            payload: {
+                timestamp: new Date().toISOString(),
+                type: "deleted",
+                data: { id },
+            },
+        }),
+        list: (data) => ({
+            event: `${namespace}:list`,
+            payload: { timestamp: new Date().toISOString(), type: "list", data },
+        }),
+    }),
+    /**
+     * Status event pattern
+     */
+    status: (namespace) => ({
+        online: () => ({
+            event: `${namespace}:online`,
+            payload: {
+                timestamp: new Date().toISOString(),
+                type: "online",
+                data: { status: "online" },
+            },
+        }),
+        offline: () => ({
+            event: `${namespace}:offline`,
+            payload: {
+                timestamp: new Date().toISOString(),
+                type: "offline",
+                data: { status: "offline" },
+            },
+        }),
+        error: (error) => ({
+            event: `${namespace}:error`,
+            payload: {
+                timestamp: new Date().toISOString(),
+                type: "error",
+                data: { error },
+            },
+        }),
+        health: (health) => ({
+            event: `${namespace}:health`,
+            payload: {
+                timestamp: new Date().toISOString(),
+                type: "health",
+                data: health,
+            },
+        }),
+    }),
+    /**
+     * Data stream pattern
+     */
+    stream: (namespace) => ({
+        start: () => ({
+            event: `${namespace}:stream:start`,
+            payload: {
+                timestamp: new Date().toISOString(),
+                type: "stream:start",
+                data: {},
+            },
+        }),
+        data: (data) => ({
+            event: `${namespace}:stream:data`,
+            payload: {
+                timestamp: new Date().toISOString(),
+                type: "stream:data",
+                data,
+            },
+        }),
+        end: () => ({
+            event: `${namespace}:stream:end`,
+            payload: {
+                timestamp: new Date().toISOString(),
+                type: "stream:end",
+                data: {},
+            },
+        }),
+        error: (error) => ({
+            event: `${namespace}:stream:error`,
+            payload: {
+                timestamp: new Date().toISOString(),
+                type: "stream:error",
+                data: { error },
+            },
+        }),
+    }),
+};
+export default {
+    WebSocketEventManager,
+    TypedEventEmitter,
+    EventTypes,
+    EventPatterns,
+};
+//# sourceMappingURL=websocketEvents.js.map