@grest-ts/ipc 0.0.5 → 0.0.7

package/src/server/HttpHandler.ts

@@ -1,107 +1,107 @@
-import * as http from 'http';
-import {GGLog} from "@grest-ts/logger";
-import {HttpMethod} from "@grest-ts/common";
-import httpProxy from "http-proxy";
-import findMyWay, {HTTPMethod} from "find-my-way";
-
-/** HTTP route handler - receives body, path params, and headers. Returns response data (or void for empty 200) */
-export type HttpRouteHandler = (body: any, pathParams?: Record<string, string>, headers?: Record<string, string>) => Promise<any>;
-
-/** Default HTTP handler for unmatched routes (proxying) - gets raw req/res */
-export type DefaultHttpHandler = (req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;
-
-interface RouteStore {
-    handler: HttpRouteHandler;
-}
-
-export class HttpHandler {
-
-    private router = findMyWay<findMyWay.HTTPVersion.V1>();
-    private routeResolver: (path: string) => string
-    private readonly proxy: httpProxy;
-
-    constructor() {
-        this.proxy = httpProxy.createProxyServer({});
-    }
-
-    public setRouteResolver(routeResolver: (path: string) => string) {
-        this.routeResolver = routeResolver
-    }
-
-    public addRoute(method: HttpMethod, path: string, handler: HttpRouteHandler): void {
-        const store: RouteStore = {handler};
-        this.router.on(method as HTTPMethod, path, () => {
-        }, store);
-    }
-
-    public removeRoute(method: HttpMethod, path: string): void {
-        this.router.off(method as HTTPMethod, path);
-    }
-
-    public async handleRequest(
-        req: http.IncomingMessage,
-        res: http.ServerResponse
-    ): Promise<void> {
-        const method = (req.method || 'GET') as HttpMethod;
-        const url = req.url || '/';
-        // Strip query string for route matching
-        const path = url.split('?')[0];
-
-        // Try to match a route
-        const result = this.router.find(method as HTTPMethod, path);
-        if (result?.store) {
-            const store = result.store as RouteStore;
-            const body = await this.readJsonBody(req);
-            // Normalize headers to Record<string, string>
-            const headers: Record<string, string> = {};
-            for (const [key, value] of Object.entries(req.headers)) {
-                if (value !== undefined) {
-                    headers[key.toLowerCase()] = Array.isArray(value) ? value[0] : value;
-                }
-            }
-            const pathParams = result.params as Record<string, string> || {};
-            try {
-                const responseData = await store.handler(body, pathParams, headers);
-                this.sendResponse(res, 200, responseData);
-            } catch (err: any) {
-                GGLog.error(this, `HTTP route error [${method} ${path}]: ${err.message}`, err);
-                this.sendResponse(res, 500, {error: err.message});
-            }
-            return;
-        }
-
-        const routeToUrl = this.routeResolver(path)
-        if (routeToUrl) {
-            GGLog.debug(this, `Proxying ${req.method} ${req.url} -> ${routeToUrl}`);
-            this.proxy.web(req, res, {target: routeToUrl}, (err: Error) => {
-                GGLog.error(this, "Proxy error", err);
-                this.sendResponse(res, 502, {issue: "Proxy error: " + err.message + " (Did the service crash?)"});
-            });
-            return;
-        }
-
-        this.sendResponse(res, 404, {error: `No route for ${method} ${path}! Did you forget to start a service that defines this path?`});
-    }
-
-    private async readJsonBody(req: http.IncomingMessage): Promise<any> {
-        return new Promise((resolve) => {
-            let bodyStr = '';
-            req.on('data', (chunk: Buffer) => {
-                bodyStr += chunk.toString();
-            });
-            req.on('end', () => {
-                try {
-                    resolve(bodyStr ? JSON.parse(bodyStr) : undefined);
-                } catch {
-                    resolve(undefined);
-                }
-            });
-            req.on('error', () => resolve(undefined));
-        });
-    }
-
-    private sendResponse(res: http.ServerResponse, status: number, data?: any): void {
-        res.writeHead(status, {'Content-Type': 'application/json'});
-        res.end(data !== undefined ? JSON.stringify(data) : '');
-    }
-}
+import * as http from 'http';
+import {GGLog} from "@grest-ts/logger";
+import {HttpMethod} from "@grest-ts/common";
+import httpProxy from "http-proxy";
+import findMyWay, {HTTPMethod} from "find-my-way";
+
+/** HTTP route handler - receives body, path params, and headers. Returns response data (or void for empty 200) */
+export type HttpRouteHandler = (body: any, pathParams?: Record<string, string>, headers?: Record<string, string>) => Promise<any>;
+
+/** Default HTTP handler for unmatched routes (proxying) - gets raw req/res */
+export type DefaultHttpHandler = (req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;
+
+interface RouteStore {
+    handler: HttpRouteHandler;
+}
+
+export class HttpHandler {
+
+    private router = findMyWay<findMyWay.HTTPVersion.V1>();
+    private routeResolver: (path: string) => string
+    private readonly proxy: httpProxy;
+
+    constructor() {
+        this.proxy = httpProxy.createProxyServer({});
+    }
+
+    public setRouteResolver(routeResolver: (path: string) => string) {
+        this.routeResolver = routeResolver
+    }
+
+    public addRoute(method: HttpMethod, path: string, handler: HttpRouteHandler): void {
+        const store: RouteStore = {handler};
+        this.router.on(method as HTTPMethod, path, () => {
+        }, store);
+    }
+
+    public removeRoute(method: HttpMethod, path: string): void {
+        this.router.off(method as HTTPMethod, path);
+    }
+
+    public async handleRequest(
+        req: http.IncomingMessage,
+        res: http.ServerResponse
+    ): Promise<void> {
+        const method = (req.method || 'GET') as HttpMethod;
+        const url = req.url || '/';
+        // Strip query string for route matching
+        const path = url.split('?')[0];
+
+        // Try to match a route
+        const result = this.router.find(method as HTTPMethod, path);
+        if (result?.store) {
+            const store = result.store as RouteStore;
+            const body = await this.readJsonBody(req);
+            // Normalize headers to Record<string, string>
+            const headers: Record<string, string> = {};
+            for (const [key, value] of Object.entries(req.headers)) {
+                if (value !== undefined) {
+                    headers[key.toLowerCase()] = Array.isArray(value) ? value[0] : value;
+                }
+            }
+            const pathParams = result.params as Record<string, string> || {};
+            try {
+                const responseData = await store.handler(body, pathParams, headers);
+                this.sendResponse(res, 200, responseData);
+            } catch (err: any) {
+                GGLog.error(this, `HTTP route error [${method} ${path}]: ${err.message}`, err);
+                this.sendResponse(res, 500, {error: err.message});
+            }
+            return;
+        }
+
+        const routeToUrl = this.routeResolver(path)
+        if (routeToUrl) {
+            GGLog.debug(this, `Proxying ${req.method} ${req.url} -> ${routeToUrl}`);
+            this.proxy.web(req, res, {target: routeToUrl}, (err: Error) => {
+                GGLog.error(this, "Proxy error", err);
+                this.sendResponse(res, 502, {issue: "Proxy error: " + err.message + " (Did the service crash?)"});
+            });
+            return;
+        }
+
+        this.sendResponse(res, 404, {error: `No route for ${method} ${path}! Did you forget to start a service that defines this path?`});
+    }
+
+    private async readJsonBody(req: http.IncomingMessage): Promise<any> {
+        return new Promise((resolve) => {
+            let bodyStr = '';
+            req.on('data', (chunk: Buffer) => {
+                bodyStr += chunk.toString();
+            });
+            req.on('end', () => {
+                try {
+                    resolve(bodyStr ? JSON.parse(bodyStr) : undefined);
+                } catch {
+                    resolve(undefined);
+                }
+            });
+            req.on('error', () => resolve(undefined));
+        });
+    }
+
+    private sendResponse(res: http.ServerResponse, status: number, data?: any): void {
+        res.writeHead(status, {'Content-Type': 'application/json'});
+        res.end(data !== undefined ? JSON.stringify(data) : '');
+    }
+}

package/src/server/IPCServer.ts

@@ -1,159 +1,159 @@
-import * as http from 'http';
-import * as net from 'net';
-import {GGLog} from "@grest-ts/logger";
-import {Duplex} from "stream";
-import {HttpMethod} from "@grest-ts/common";
-import {HttpHandler} from "./HttpHandler";
-import {SocketHandler, SocketMessage} from "./SocketHandler";
-import {IPCClientRequest, IPCServerRequest} from "../common/IPCTypes";
-import {GGLocator, GGLocatorScope} from "@grest-ts/locator";
-import {GGContext} from "@grest-ts/context";
-import {GG_TRACE} from "@grest-ts/trace";
-
-export class IPCServer {
-
-    private readonly httpServer: http.Server;
-    private readonly httpHandler: HttpHandler;
-    private readonly socketHandler: SocketHandler;
-
-    private readonly expectedPort: number;
-    private port: number = 0;
-    private url: string = '';
-
-    private readonly connections: Set<net.Socket> = new Set();
-
-    private readonly scope: GGLocatorScope;
-
-    constructor(port: number = 0) {
-        this.expectedPort = port;
-        this.scope = GGLocator.getScope();
-
-        // Create handlers
-        this.httpHandler = new HttpHandler();
-        this.socketHandler = new SocketHandler();
-
-        // Create HTTP server
-        this.httpServer = http.createServer(async (req, res) => {
-            await new GGContext("LocalRouter").run(async () => {
-                GG_TRACE.init();
-                await this.httpHandler.handleRequest(req, res);
-            });
-        });
-
-        // Handle WebSocket upgrades
-        // Note: Incoming TCP connections start with no async context (they originate from libuv/OS layer).
-        this.httpServer.on('upgrade', async (req, socket, head) => {
-            this.scope.ensureEntered();
-            await new GGContext("LocalRouter").run(async () => {
-                GG_TRACE.init();
-                await this.socketHandler.handleUpgrade(req, socket as Duplex, head);
-            });
-        });
-
-        // Track connections for cleanup
-        this.httpServer.on('connection', (conn) => {
-            this.connections.add(conn);
-            conn.on('close', () => this.connections.delete(conn));
-        });
-    }
-
-    public static defineRequest<Req, Res>(name: string): IPCServerRequest<Req, Res> {
-        return name as IPCServerRequest<Req, Res>;
-    }
-
-    // -----------------------------------------------
-    // Lifecycle
-    // -----------------------------------------------
-
-    public async start(): Promise<boolean> {
-        return new Promise<boolean>((resolve, reject) => {
-            const errorHandler = (err: any) => {
-                if (err.code === 'EADDRINUSE') {
-                    resolve(false);
-                } else {
-                    reject(err);
-                }
-            };
-
-            this.httpServer.once('error', errorHandler);
-
-            this.httpServer.listen(this.expectedPort, '0.0.0.0', () => {
-                this.scope.ensureEntered();
-                this.port = (this.httpServer.address() as any).port;
-                this.url = `http://localhost:${this.port}`;
-                this.httpServer.removeListener('error', errorHandler);
-                GGLog.info(this, `Internal server started on port ${this.port}`);
-                resolve(true);
-            });
-        });
-    }
-
-    public async teardown(): Promise<void> {
-        // Teardown socket handler (closes clients and WSS)
-        await this.socketHandler.teardown();
-
-        // Close all HTTP connections
-        this.connections.forEach(conn => conn.destroy());
-        this.connections.clear();
-
-        // Close the server
-        await new Promise<void>((resolve, reject) => {
-            this.httpServer.close((err) => {
-                this.scope.ensureEntered();
-                if (err) reject(err);
-                else resolve();
-            });
-        });
-
-        GGLog.info(this, 'Internal server stopped');
-    }
-
-    // -----------------------------------------------
-    // Handling http/socket requests that services send between each other. Can intercept http here.
-    // -----------------------------------------------
-
-    public interceptHttp(method: HttpMethod, path: string, handler: (body: any, pathParams?: Record<string, string>, headers?: Record<string, string>) => Promise<any>): void {
-        this.httpHandler.addRoute(method, path, handler);
-    }
-
-    public removeInterceptHttp(method: HttpMethod, path: string): void {
-        this.httpHandler.removeRoute(method, path);
-    }
-
-    public setRouteProxyResolver(resolver: (path: string) => string) {
-        this.httpHandler.setRouteResolver(resolver);
-        this.socketHandler.setRouteResolver(resolver);
-    }
-
-    // -----------------------------------------------
-    // Grest Framework internal messaging between either local discovery server or local test server.
-    // -----------------------------------------------
-
-    public onFrameworkMessage<Req, Res>(
-        type: IPCServerRequest<Req, Res>,
-        handler: (payload: Req, msg: SocketMessage) => Promise<Res>
-    ): void {
-        this.socketHandler.onMessage(type, async (msg) => handler(msg.data as Req, msg));
-    }
-
-    public async sendFrameworkMessage<Req, Res>(
-        runtimeId: string,
-        type: IPCClientRequest<Req, Res>,
-        payload: Req,
-        timeoutMs?: number
-    ): Promise<Res> {
-        return this.socketHandler.request<Res>(runtimeId, type, payload, timeoutMs);
-    }
-
-    // -----------------------------------------------
-    // Accessors
-    // -----------------------------------------------
-
-    public getPort(): number {
-        return this.port;
-    }
-
-    public getUrl(): string {
-        return this.url;
-    }
-}
+import * as http from 'http';
+import * as net from 'net';
+import {GGLog} from "@grest-ts/logger";
+import {Duplex} from "stream";
+import {HttpMethod} from "@grest-ts/common";
+import {HttpHandler} from "./HttpHandler";
+import {SocketHandler, SocketMessage} from "./SocketHandler";
+import {IPCClientRequest, IPCServerRequest} from "../common/IPCTypes";
+import {GGLocator, GGLocatorScope} from "@grest-ts/locator";
+import {GGContext} from "@grest-ts/context";
+import {GG_TRACE} from "@grest-ts/trace";
+
+export class IPCServer {
+
+    private readonly httpServer: http.Server;
+    private readonly httpHandler: HttpHandler;
+    private readonly socketHandler: SocketHandler;
+
+    private readonly expectedPort: number;
+    private port: number = 0;
+    private url: string = '';
+
+    private readonly connections: Set<net.Socket> = new Set();
+
+    private readonly scope: GGLocatorScope;
+
+    constructor(port: number = 0) {
+        this.expectedPort = port;
+        this.scope = GGLocator.getScope();
+
+        // Create handlers
+        this.httpHandler = new HttpHandler();
+        this.socketHandler = new SocketHandler();
+
+        // Create HTTP server
+        this.httpServer = http.createServer(async (req, res) => {
+            await new GGContext("LocalRouter").run(async () => {
+                GG_TRACE.init();
+                await this.httpHandler.handleRequest(req, res);
+            });
+        });
+
+        // Handle WebSocket upgrades
+        // Note: Incoming TCP connections start with no async context (they originate from libuv/OS layer).
+        this.httpServer.on('upgrade', async (req, socket, head) => {
+            this.scope.ensureEntered();
+            await new GGContext("LocalRouter").run(async () => {
+                GG_TRACE.init();
+                await this.socketHandler.handleUpgrade(req, socket as Duplex, head);
+            });
+        });
+
+        // Track connections for cleanup
+        this.httpServer.on('connection', (conn) => {
+            this.connections.add(conn);
+            conn.on('close', () => this.connections.delete(conn));
+        });
+    }
+
+    public static defineRequest<Req, Res>(name: string): IPCServerRequest<Req, Res> {
+        return name as IPCServerRequest<Req, Res>;
+    }
+
+    // -----------------------------------------------
+    // Lifecycle
+    // -----------------------------------------------
+
+    public async start(): Promise<boolean> {
+        return new Promise<boolean>((resolve, reject) => {
+            const errorHandler = (err: any) => {
+                if (err.code === 'EADDRINUSE') {
+                    resolve(false);
+                } else {
+                    reject(err);
+                }
+            };
+
+            this.httpServer.once('error', errorHandler);
+
+            this.httpServer.listen(this.expectedPort, '0.0.0.0', () => {
+                this.scope.ensureEntered();
+                this.port = (this.httpServer.address() as any).port;
+                this.url = `http://localhost:${this.port}`;
+                this.httpServer.removeListener('error', errorHandler);
+                GGLog.info(this, `Internal server started on port ${this.port}`);
+                resolve(true);
+            });
+        });
+    }
+
+    public async teardown(): Promise<void> {
+        // Teardown socket handler (closes clients and WSS)
+        await this.socketHandler.teardown();
+
+        // Close all HTTP connections
+        this.connections.forEach(conn => conn.destroy());
+        this.connections.clear();
+
+        // Close the server
+        await new Promise<void>((resolve, reject) => {
+            this.httpServer.close((err) => {
+                this.scope.ensureEntered();
+                if (err) reject(err);
+                else resolve();
+            });
+        });
+
+        GGLog.info(this, 'Internal server stopped');
+    }
+
+    // -----------------------------------------------
+    // Handling http/socket requests that services send between each other. Can intercept http here.
+    // -----------------------------------------------
+
+    public interceptHttp(method: HttpMethod, path: string, handler: (body: any, pathParams?: Record<string, string>, headers?: Record<string, string>) => Promise<any>): void {
+        this.httpHandler.addRoute(method, path, handler);
+    }
+
+    public removeInterceptHttp(method: HttpMethod, path: string): void {
+        this.httpHandler.removeRoute(method, path);
+    }
+
+    public setRouteProxyResolver(resolver: (path: string) => string) {
+        this.httpHandler.setRouteResolver(resolver);
+        this.socketHandler.setRouteResolver(resolver);
+    }
+
+    // -----------------------------------------------
+    // Grest Framework internal messaging between either local discovery server or local test server.
+    // -----------------------------------------------
+
+    public onFrameworkMessage<Req, Res>(
+        type: IPCServerRequest<Req, Res>,
+        handler: (payload: Req, msg: SocketMessage) => Promise<Res>
+    ): void {
+        this.socketHandler.onMessage(type, async (msg) => handler(msg.data as Req, msg));
+    }
+
+    public async sendFrameworkMessage<Req, Res>(
+        runtimeId: string,
+        type: IPCClientRequest<Req, Res>,
+        payload: Req,
+        timeoutMs?: number
+    ): Promise<Res> {
+        return this.socketHandler.request<Res>(runtimeId, type, payload, timeoutMs);
+    }
+
+    // -----------------------------------------------
+    // Accessors
+    // -----------------------------------------------
+
+    public getPort(): number {
+        return this.port;
+    }
+
+    public getUrl(): string {
+        return this.url;
+    }
+}