geonix 1.20.1 → 1.20.2

package/eslint.config.js

@@ -14,7 +14,8 @@ export default [
             }
         },
         rules: {
-            // "no-console": "error",
+            "curly": "error",
+            "no-console": "error",
             semi: "error",
             "no-unused-vars": ["error", { argsIgnorePattern: "^_.*" }],
             "no-constant-condition": ["error", { checkLoops: false }],

package/index.d.ts

@@ -65,6 +65,14 @@ export class Gateway {
     constructor(opts: any);
     #private;
 }
+export class Logger {
+    constructor(options: any);
+    info(...args: any[]): void;
+    error(...args: any[]): void;
+    debug(...args: any[]): void;
+    #private;
+}
+export const logger: Logger;
 export const registry: Registry;
 /**
  * Registry maintains a local list of available services and their versions.
@@ -138,6 +146,17 @@ export class Service {
     $getServiceInfo(): {};
     #private;
 }
+export type ServiceOptions = {
+    middleware: {
+        json: boolean;
+        raw: boolean;
+        cookies: boolean;
+    };
+    /**
+     * Enable full beacon
+     */
+    fullBeacon: boolean;
+};
 /**
  * Converts data to stream
  *
@@ -151,6 +170,7 @@ export function getReadable(object: any): Promise<any>;
 export function streamToBuffer(object: any): Promise<any>;
 export function streamToString(object: any): Promise<any>;
 export const stats: {};
+export const activeStreams: {};
 /**
  * Parse nats:// URL
  * @param {string} url
@@ -158,6 +178,7 @@ export const stats: {};
  */
 export function parseURL(url: string): any;
 export function getFirstItemFromAsyncIterable(asyncIterable: any): Promise<any>;
+export function getNetworkAddresses(): any[];
 export function sleep(delay: number): Promise<any>;
 export function picoid(size?: number): any;
 export function hash(data: string | Buffer): any;
@@ -176,7 +197,6 @@ export function ServeStatic(root: any, options?: {}): any;
 export const webserver: WebServer;
 declare class WebServer {
     start(): Promise<void>;
-    getAddresses(): any[];
     getPort(): any;
     router(): any;
     waitUntilReady(): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "geonix",
-    "version": "1.20.1",
+    "version": "1.20.2",
     "type": "module",
     "description": "",
     "bin": {
@@ -10,6 +10,7 @@
     "scripts": {
         "test": "echo \"Error: no test specified\" && exit 1",
         "build": "npx tsc && cat build/* > index.d.ts && rm -rf build",
+        "lint": "npx eslint src",
         "deploy": "npm run build && npm publish"
     },
     "author": "Davor Tarandek <dtarandek@tria.hr>",

package/src/Connection.js

@@ -1,7 +1,8 @@
 import { connect, JSONCodec } from "nats";
-import { parseURL, picoid, sleep } from "./Util.js";
+import { getFirstItemFromAsyncIterable, parseURL, picoid, sleep } from "./Util.js";
 import { Stream } from "./Stream.js";
 import { webserver } from "./WebServer.js";
+import { logger } from "./Logger.js";
 
 // -------------------------------------------------------------------------------------------------
 const CONNECTION_TIMEOUT = 10000;
@@ -9,6 +10,16 @@ const CONNECTION_TIMEOUT = 10000;
 const defaultRequestOptions = {
     timeout: 300000
 };
+
+const defaultConnectionOptions = {
+    timeout: CONNECTION_TIMEOUT,
+    reconnect: true,
+    debug: process.env.TRANSPORT_DEBUG === "true",
+    maxReconnectAttempts: 30,
+    pingInterval: 30000,
+    waitOnFirstConnect: true,
+    connections: 1
+};
 // -------------------------------------------------------------------------------------------------
 
 /**
@@ -36,17 +47,8 @@ class Connection {
      * @param {string} transport 
      */
     async start(transport = process.env.TRANSPORT || "nats://localhost") {
-        const defaults = {
-            timeout: CONNECTION_TIMEOUT,
-            reconnect: true,
-            debug: process.env.TRANSPORT_DEBUG === "true",
-            maxReconnectAttempts: 30,
-            pingInterval: 30000,
-            waitOnFirstConnect: true,
-            connections: 1
-        };
         const options = {
-            ...defaults,
+            ...defaultConnectionOptions,
             ...parseURL(transport)
         };
 
@@ -54,7 +56,7 @@ class Connection {
             this.#connections.push(await connect(options));
         }
 
-        console.log("gx.connection.connected");
+        logger.info("gx.connection.connected");
 
         this.#ready = true;
 
@@ -64,7 +66,7 @@ class Connection {
 
     async monitorStatus() {
         for await (const event of this.#getConnection().status()) {
-            console.log("gx.connection.status", JSON.stringify(event));
+            logger.info("gx.connection.status", JSON.stringify(event));
         }
     }
 
@@ -76,13 +78,13 @@ class Connection {
         await Promise.all(this.#connections.map(connection => connection.closed()));
 
         this.#closed = true;
-        console.log("gx.connection.closed");
+        logger.info("gx.connection.closed");
 
         webserver.stop();
 
         await sleep(5000);
 
-        console.log("gx.terminate");
+        logger.info("gx.terminate");
         process.exit(1);
     }
 
@@ -90,8 +92,9 @@ class Connection {
      * Wait for the connection to be fully established
      */
     async waitUntilReady() {
-        while (!this.#ready)
+        while (!this.#ready) {
             await sleep(100);
+        }
     }
 
     /**
@@ -102,14 +105,16 @@ class Connection {
      * @returns void
      */
     async publish(subject, json) {
-        if (this.#draining || this.#closed)
+        if (this.#draining || this.#closed) {
             return;
+        }
 
         let payload = codec.encode(json);
 
         // if payload is too big, convert it to Stream
-        if (payload.length > this.getMaxPayloadSize())
+        if (payload.length > this.getMaxPayloadSize()) {
             payload = codec.encode(Stream(JSON.stringify(json)));
+        }
 
         await this.#getConnection().publish(subject, payload);
     }
@@ -122,8 +127,9 @@ class Connection {
      * @returns void
      */
     async publishRaw(subject, data) {
-        if (this.#draining || this.#closed)
+        if (this.#draining || this.#closed) {
             return;
+        }
 
         await this.#getConnection().publish(subject, data);
     }
@@ -147,16 +153,17 @@ class Connection {
         let payload = codec.encode({ $r: respondTo, p: json });
 
         // if payload is too big, convert it to Stream
-        if (payload.length > this.getMaxPayloadSize())
+        if (payload.length > this.getMaxPayloadSize()) {
             payload = codec.encode(Stream(JSON.stringify({ $r: respondTo, p: json })));
+        }
 
         const nc = this.#getConnection();
         let response = await nc.subscribe(respondTo, { max: 1, ...options });
 
         await nc.publish(subject, payload);
 
-        for await (let event of response)
-            return codec.decode(event.data);
+        const event = await getFirstItemFromAsyncIterable(response);
+        return codec.decode(event.data);
     }
 
     async subscribe(subject, options) {
@@ -194,8 +201,9 @@ export const connection = new Connection();
 connection.start();
 
 export const stopConnection = () => {
-    if (!connection)
+    if (!connection) {
         return;
+    }
 
     connection.drain();
 };

package/src/Gateway.js

@@ -8,14 +8,15 @@ import expressWs from "express-ws";
 import querystring from "querystring";
 import semver from "semver";
 import { WebSocket } from "ws";
+import { logger } from "./Logger.js";
 
 const raw = express.raw({ limit: "100mb" });
 
 const DEBUG_ENDPOINT = "/lZ6jD2eC3iP0zB3jJ1yJ9pM8gG3yI3vS";
 const endpointMatcher = /^((?<options>.+)\|)?(?<verb>WS|GET|POST|PATCH|PUT|DELETE|HEAD|OPTIONS|ALL)\s(?<url>.*)/;
 
-const logger = (req, res, next) => {
-    console.info(`HTTP ${req.method} ${req.url}`);
+const requestLogger = (req, res, next) => {
+    logger.info(`HTTP ${req.method} ${req.url}`);
 
     next();
 };
@@ -63,10 +64,10 @@ export class Gateway {
         this.#port = process.env.PORT || port;
         this.#api.listen(this.#port);
 
-        console.debug(`geonix.gateway: listening on http://0.0.0.0:${this.#port}`);
+        logger.debug(`geonix.gateway: listening on http://0.0.0.0:${this.#port}`);
 
         // logging
-        this.#api.use(logger);
+        this.#api.use(requestLogger);
 
         // cors
         this.#api.use((req, res, next) => {
@@ -86,8 +87,9 @@ export class Gateway {
         });
 
         // debug router (only available in non-production environments)
-        if (process.env.NODE_ENV !== "production")
+        if (process.env.NODE_ENV !== "production") {
             this.#api.use(DEBUG_ENDPOINT, this.#debugRouter());
+        }
 
         this.#api.use((req, res, next) => {
             if (this.#opts.beforeRequest) {
@@ -100,10 +102,8 @@ export class Gateway {
         this.#api.use(raw, (req, res, next) => {
             stats.requests++;
 
-            if (this.#router)
-                this.#router(req, res, next);
-            else
-                next();
+            if (this.#router) { this.#router(req, res, next); }
+            else { next(); }
         });
 
         this.#api.use((req, res, next) => {
@@ -126,8 +126,9 @@ export class Gateway {
         });
 
         setInterval(() => {
-            if (this.#rebuildRouter)
+            if (this.#rebuildRouter) {
                 this.#buildRouter();
+            }
         }, 1000);
 
         while (true) {
@@ -143,12 +144,12 @@ export class Gateway {
                     break;
                 }
             } catch (e) {
-                console.error(e);
+                logger.error(e);
             }
         }
 
         // terminate process
-        console.debug("geonix.gateway: stopped");
+        logger.debug("geonix.gateway: stopped");
         process.exit(0);
     }
 
@@ -156,15 +157,14 @@ export class Gateway {
         let entries = Object.values(registry.getEntries());
 
         const processEntry = async (entry) => {
-            if (this.#registry[entry.i] !== undefined)
-                return false;
+            if (this.#registry[entry.i] !== undefined) { return false; }
 
-            console.log(`gateway.onServiceAdded: ${entry.n}@${entry.v} (#${entry.i})`);
+            logger.info(`gateway.onServiceAdded: ${entry.n}@${entry.v} (#${entry.i})`);
 
             // figure out if endpoints is reachable via direct http call
             let backend;
             if (entry.a) {
-                for (let address of entry.a)
+                for (let address of entry.a) {
                     try {
                         const ac = new AbortController();
                         const timeout = setTimeout(() => ac.abort(), 500);
@@ -172,12 +172,13 @@ export class Gateway {
                         clearTimeout(timeout);
                         if (result.status === "healthy" && result.services?.includes(entry.n)) {
                             backend = address;
-                            console.log(`${entry.n}@${entry.v} (#${entry.i}) directly reachable @ ${address}`);
+                            logger.info(`${entry.n}@${entry.v} (#${entry.i}) directly reachable @ ${address}`);
                             break;
                         }
                     } catch {
                         // silently ignore errors
                     }
+                }
             }
 
             let proxy;
@@ -190,7 +191,7 @@ export class Gateway {
                     try {
                         await this.#proxyHttpOverNats(streamId, entry, client);
                     } catch (e) {
-                        console.error("nats.proxy.error", e);
+                        logger.error("nats.proxy.error", e);
                         client.destroy();
                     }
                 }, 50000, 10000);
@@ -204,8 +205,9 @@ export class Gateway {
 
         entries = (await Promise.all(entries.map(processEntry))).filter(result => result === true);
 
-        if (entries.length > 0)
+        if (entries.length > 0) {
             this.#rebuildRouter = true;
+        }
     }
 
     async #handleRemovedServices() {
@@ -215,7 +217,7 @@ export class Gateway {
         for (let { entry, proxy } of localEntries) {
             if (registryEntries[entry.i] === undefined) {
                 proxy?.server?.close();
-                console.log(`gateway.onServiceRemoved: ${entry.n}@${entry.v}`);
+                logger.info(`gateway.onServiceRemoved: ${entry.n}@${entry.v}`);
                 delete this.#registry[entry.i];
 
                 this.#rebuildRouter = true;
@@ -290,8 +292,7 @@ export class Gateway {
             });
 
             const dataLoop = async () => {
-                for await (const event of ingress)
-                    client.write(event.data);
+                for await (const event of ingress) { client.write(event.data); }
             };
 
             dataLoop();
@@ -321,15 +322,16 @@ export class Gateway {
                 inbound.on("close", () => backend.close());
             });
         } catch (e) {
-            console.error(e);
+            logger.error(e);
         }
     }
 
     async #buildRouter() {
-        if (this.#buildRouterRunning)
+        if (this.#buildRouterRunning) {
             return;
+        }
 
-        console.debug("gateway.buildRouter");
+        logger.debug("gateway.buildRouter");
 
         this.#rebuildRouter = false;
         this.#buildRouterRunning = true;
@@ -359,8 +361,8 @@ export class Gateway {
                                 backend: [backend]
                             });
                         } catch (e) {
-                            console.error("gateway.buildRouter.error:", entry);
-                            console.error("gateway.buildRouter.error:", e);
+                            logger.error("gateway.buildRouter.error:", entry);
+                            logger.error("gateway.buildRouter.error:", e);
                         }
                     }
                 }
@@ -372,12 +374,13 @@ export class Gateway {
                 const version = endpoints[index].version;
                 const url = `${endpoints[index].endpoint.verb} ${endpoints[index].endpoint.url}`;
 
-                for (let n = 0; n < index; n++)
+                for (let n = 0; n < index; n++) {
                     if (`${endpoints[n].endpoint.verb} ${endpoints[n].endpoint.url}` === url && endpoints[n].version === version) {
                         endpoints[n].backend = endpoints[n].backend.concat(endpoints[index].backend);
                         endpoints.splice(index, 1);
                         break;
                     }
+                }
             }
 
             // sort endpoints by order, if there is one
@@ -397,21 +400,22 @@ export class Gateway {
                     router.ws(uri, (ws, req) => {
                         const url = req.originalUrl.replace(/\/\.websocket$/, "");
 
-                        console.debug("proxy.web.ws.to:", backend + req.originalUrl);
+                        logger.debug("proxy.web.ws.to:", backend + req.originalUrl);
                         this.#proxyWebsocketOverNats(`ws://${backend}${url}`, ws, req);
                     });
-                } else
+                } else {
                     router[verb](uri, async (req, res, _next) => {
                         stats.proxied++;
                         backend = endpoint.backend[endpoint.requests++ % endpoint.backend.length];
 
                         try {
-                            console.debug("proxy.web.to:", backend + req.originalUrl);
+                            logger.debug("proxy.web.to:", backend + req.originalUrl);
                             await proxyHttp(`http://${backend}`, req, res);
                         } catch (e) {
-                            console.error("proxy.web.error:", e);
+                            logger.error("proxy.web.error:", e);
                         }
                     });
+                }
             }
 
             this.#router = router;

package/src/Logger.js

@@ -0,0 +1,34 @@
+const defaultLoggerOptions = {
+    timestamp: true
+};
+
+export class Logger {
+
+    #options = defaultLoggerOptions;
+
+    constructor(options) {
+        this.#options = { ...this.#options, ...options };
+    }
+
+    #log(...args) {
+        const ts = this.#options.timestamp ? new Date().toISOString() : undefined;
+
+        // eslint-disable-next-line no-console
+        console.log(...[ts, ...args].filter($ => $));
+    }
+
+    info(...args) {
+        this.#log("INF", ...args);
+    }
+
+    error(...args) {
+        this.#log("ERR", ...args);
+    }
+
+    debug(...args) {
+        this.#log("DBG", ...args);
+    }
+
+}
+
+export const logger = new Logger();

package/src/Registry.js

@@ -44,8 +44,9 @@ class Registry extends EventEmitter {
                 timeout: Date.now() + REGISTRY_ENTRY_TIMEOUT
             };
 
-            if (!exists)
+            if (!exists) {
                 this.emit("added", this.#registry[data.i]);
+            }
         }
     }
 
@@ -83,14 +84,16 @@ class Registry extends EventEmitter {
             let matchVersion = version ? semver.satisfies(entry.v, version) : true;
             let matchId = id ? entry.id === id : true;
 
-            if (matchName && matchVersion && matchId)
+            if (matchName && matchVersion && matchId) {
                 matches.push(entry);
+            }
         }
 
         if (matches.length > 0) {
             // return instance id in case of id matching
-            if (id)
+            if (id) {
                 return matches[0].i;
+            }
 
             // sort matched services in the registry by version
             matches.sort((a, b) => semver.rcompare(a.v, b.v));

package/src/Request.js

@@ -5,6 +5,7 @@ import { hash, sleep } from "./Util.js";
 import { RequestOptionsClass } from "./RequestOptions.js";
 import { isStream, streamToString } from "./Stream.js";
 import { inspect } from "node:util";
+import { logger } from "./Logger.js";
 
 const REGISTRY_TIMEOUT = 300000;
 
@@ -44,8 +45,9 @@ function getOriginator() {
     for (const item of stack) {
         const typeName = item.getTypeName();
 
-        if (Service.serviceClasses.includes(typeName))
+        if (Service.serviceClasses.includes(typeName)) {
             return `${typeName}.${item.getMethodName()}`;
+        }
     }
 }
 
@@ -64,8 +66,9 @@ export async function Request(service, method, args, context, options) {
     const { name, version, id } = match.groups;
 
     // allow passing RequestOptions as first arg
-    if (args?.length > 0 && args[0] instanceof RequestOptionsClass)
+    if (args?.length > 0 && args[0] instanceof RequestOptionsClass) {
         options = (args.shift())?.options;
+    }
 
     let identifier = null;
 
@@ -75,8 +78,9 @@ export async function Request(service, method, args, context, options) {
     let retries = Math.floor(registryTimeout / delay);
     while (identifier == null && retries-- > 0) {
         identifier = registry.getIdentifier(name, version, id);
-        if (!identifier)
+        if (!identifier) {
             await sleep(delay);
+        }
     }
 
     return directRequest(identifier, method, args, context, options, service);
@@ -108,10 +112,11 @@ export async function directRequest(identifier, method, args, context, options,
             options);
 
         // automatically process streamed response
-        if (isStream(response))
+        if (isStream(response)) {
             response = JSON.parse(await streamToString(response));
+        }
     } catch (e) {
-        console.debug("GxError: directRequest", inspect({
+        logger.debug("GxError: directRequest", inspect({
             originator, service: service ?? identifier, method, args, context, options,
             error: e, duration: Date.now() - requestBegin
         }));
@@ -119,12 +124,14 @@ export async function directRequest(identifier, method, args, context, options,
         throw e;
     }
 
-    if (!response)
+    if (!response) {
         throw Error("Request: invalid response");
+    }
 
     // got error?
-    if (response.e)
+    if (response.e) {
         throw Error(`Request: remote error: ${response.e}`);
+    }
 
     return response.r;
 }
@@ -147,10 +154,12 @@ export async function Publish(subject, payload) {
  * @returns 
  */
 export async function Subscribe(subject, callback) {
-    if (typeof callback !== "function")
+    if (typeof callback !== "function") {
         return;
+    }
 
     const subscription = await connection.subscribe(`gx.sub.${subject}`);
-    for await (const event of subscription)
+    for await (const event of subscription) {
         callback(event.data);
+    }
 }

package/src/RequestOptions.js

@@ -1,5 +1,6 @@
 export class RequestOptionsClass {
     options;
+
     constructor(options) {
         this.options = options;
     }

package/src/Service.js

@@ -1,11 +1,12 @@
 import { codec, connection } from "./Connection.js";
-import { picoid, sleep, hash, getSecondsSinceMidnight, OverlayObject, GeonixVersion, getFirstItemFromAsyncIterable } from "./Util.js";
+import { picoid, sleep, hash, getSecondsSinceMidnight, OverlayObject, GeonixVersion, getFirstItemFromAsyncIterable, getNetworkAddresses } from "./Util.js";
 import { webserver } from "./WebServer.js";
 import { createConnection } from "net";
 import { EOL } from "os";
 import cookieParser from "cookie-parser";
 import express from "express";
 import { isStream, streamToString } from "./Stream.js";
+import { logger } from "./Logger.js";
 
 const protectedMethodNames = ["constructor", "onStart"];
 const endpointMatcher = /^((?<options>.+)\|)?(?<verb>WS|SUB|GET|POST|PATCH|PUT|DELETE|HEAD|OPTIONS|ALL)\s(?<url>.*)/;
@@ -15,14 +16,33 @@ const ERROR_END_DELIMITER = "-".repeat(40);
 
 const json = express.json({ limit: "100mb" });
 const raw = express.raw({ type: "*/*", limit: "100mb" });
+const cookies = cookieParser();
+
+/**
+ * @typedef {Object} ServiceOptions
+ * @property {Object} middleware
+ * @property {boolean} middleware.json Enable JSON middleware
+ * @property {boolean} middleware.raw Enable RAW middleware
+ * @property {boolean} middleware.cookies Enable cookies middleware
+ * @property {boolean} fullBeacon Enable full beacon
+ */
+const defaultServiceOptions = {
+    middleware: {
+        json: true,
+        raw: true,
+        cookies: true
+    },
+    fullBeacon: true
+};
 
 export class Service {
 
     static serviceClasses = [];
 
     static start(options = {}) {
-        if (!this.serviceClasses.includes(this.prototype.constructor.name))
+        if (!this.serviceClasses.includes(this.prototype.constructor.name)) {
             this.serviceClasses.push(this.prototype.constructor.name);
+        }
 
         const instance = new this();
         instance.#start(options);
@@ -31,21 +51,28 @@ export class Service {
     // ---------------------------------------------------------------------------------------------    
 
     #me = {};
-    #options = {};
+    #options = defaultServiceOptions;
 
     async #start(options = {}) {
-        this.#options = options;
+        this.#options = { ...this.#options, ...options };
 
         await webserver.waitUntilReady();
         await connection.waitUntilReady();
 
-        const fields = Object.getOwnPropertyNames(this).filter(isEndpointFilter).concat(Object.getOwnPropertyNames(this.constructor.prototype));
+        const fields = Object.getOwnPropertyNames(this)
+            .filter(isEndpointFilter)
+            .concat(Object.getOwnPropertyNames(this.constructor.prototype));
 
         // preserve order of endpoints as defined in the source
         const serviceSource = this.constructor.toString().split("\n");
         fields.sort((a, b, ia = -1, ib = -1) => {
-            for (let line = 0; line < serviceSource.length; line++) ia = serviceSource[line].includes(a) ? line : ia;
-            for (let line = 0; line < serviceSource.length; line++) ib = serviceSource[line].includes(b) ? line : ib;
+            for (let line = 0; line < serviceSource.length; line++) {
+                ia = serviceSource[line].includes(a) ? line : ia;
+            }
+
+            for (let line = 0; line < serviceSource.length; line++) {
+                ib = serviceSource[line].includes(b) ? line : ib;
+            }
             return ia - ib;
         });
 
@@ -65,7 +92,7 @@ export class Service {
             // geonix version
             gx: GeonixVersion,
             // IP addresses
-            a: webserver.getAddresses().map(address => `${address}:${webserver.getPort()}`)
+            a: getNetworkAddresses().map(address => `${address}:${webserver.getPort()}`)
         };
 
         // check if method takes context as first argument
@@ -79,7 +106,7 @@ export class Service {
         this.#directListener();
         this.#webserver();
 
-        console.log("gx.service.start", this.#me.n, this.#me.v);
+        logger.info("gx.service.start", this.#me.n, this.#me.v);
 
         // execute onStart method, if present
         if (this.onStart) {
@@ -93,7 +120,11 @@ export class Service {
      */
     async #beacon() {
         while (true) {
-            connection.publish("gx2.beacon", { i: this.#me.i });
+            if (this.#options.fullBeacon) {
+                connection.publish("gx2.beacon", this.#me);
+            } else {
+                connection.publish("gx2.beacon", { i: this.#me.i });
+            }
             await sleep(1000);
         }
     }
@@ -108,11 +139,9 @@ export class Service {
         for await (let event of subscription) {
             let call = codec.decode(event.data);
 
-            if (isStream(call))
-                call = JSON.parse(await streamToString(call));
+            if (isStream(call)) { call = JSON.parse(await streamToString(call)); }
 
-            if (call.$r && call.p)
-                this.#onCall(call.p, (json) => connection.publish(call.$r, json));
+            if (call.$r && call.p) { this.#onCall(call.p, (json) => connection.publish(call.$r, json)); }
         }
     }
 
@@ -126,11 +155,13 @@ export class Service {
         for await (let event of subscription) {
             let call = codec.decode(event.data);
 
-            if (isStream(call))
+            if (isStream(call)) {
                 call = JSON.parse(await streamToString(call));
+            }
 
-            if (call.$r && call.p)
+            if (call.$r && call.p) {
                 this.#onCall(call.p, (json) => connection.publish(call.$r, json));
+            }
         }
     }
 
@@ -142,11 +173,24 @@ export class Service {
         const endpoints = this.#me.m
             .filter(isEndpointFilter);
 
-        if (!endpoints || endpoints.length === 0)
+        if (!endpoints || endpoints.length === 0) {
             return;
+        }
 
         const router = webserver.router();
-        router.use(json, raw, cookieParser());
+
+        // setup defualt middlewares
+        if (this.#options.middleware.json) {
+            router.use(json);
+        }
+        if (this.#options.middleware.raw) {
+            router.use(raw);
+        }
+        if (this.#options.middleware.cookies) {
+            router.use(cookies);
+        }
+
+        // register endpoints
         for (let endpoint of endpoints) {
             let { verb, url: uri } = endpointMatcher.exec(endpoint)?.groups || {};
             verb = verb.toLowerCase();
@@ -158,8 +202,9 @@ export class Service {
 
             handlers = [...handlersBefore, ...handlers, ...handlersAfter];
 
-            for (let n = 0; n < handlers.length; n++)
+            for (let n = 0; n < handlers.length; n++) {
                 handlers[n] = handlers[n].bind(this);
+            }
 
             switch (verb) {
                 case "ws":
@@ -180,8 +225,9 @@ export class Service {
     async #sub(subject, handler) {
         const subscription = await connection.subscribe(`gx.sub.${subject}`);
         const processor = async () => {
-            for await (const event of subscription)
+            for await (const event of subscription) {
                 handler(event.data);
+            }
         };
         processor();
     }
@@ -198,13 +244,15 @@ export class Service {
         const method = this[methodName];
         let _args = args;
 
-        if (!method)
+        if (!method) {
             return respond({ e: `unknown method (${this.#me.n}.${methodName})` });
+        }
 
         try {
             // inject context as first argument
-            if (method.takesContext)
+            if (method.takesContext) {
                 _args = [OverlayObject(context, { caller, me: this.#me }), ..._args];
+            }
 
             respond({ r: await method.apply(this, _args) });
         } catch (e) {

package/src/Stream.js

@@ -1,10 +1,13 @@
 import { Readable } from "stream";
 import { connection } from "./Connection.js";
-import { picoid, StreamChunker } from "./Util.js";
+import { getFirstItemFromAsyncIterable, getNetworkAddresses, picoid, StreamChunker } from "./Util.js";
+import { logger } from "./Logger.js";
+import { webserver } from "./WebServer.js";
 
 const CHUNK_SIZE = 1024 * 128;
 
 export const stats = {};
+export const activeStreams = {};
 
 /**
  * Converts data to stream
@@ -14,15 +17,17 @@ export const stats = {};
  * @returns 
  */
 export function Stream(data, tag = "_") {
-    if (isStream(data))
+    if (isStream(data)) {
         return data;
+    }
 
     const id = picoid();
     let readable = data;
 
     // convert Buffer or string to a Readable
-    if (!(readable.pipe && readable.readable))
+    if (!(readable.pipe && readable.readable)) {
         readable = Readable.from(Buffer.from(data));
+    }
 
     // split the stream is smaller chunks
     const transform = StreamChunker(Math.min(connection.getMaxPayloadSize(), CHUNK_SIZE));
@@ -30,23 +35,38 @@ export function Stream(data, tag = "_") {
     readable = transform;
 
     stats[tag] = stats[tag] !== undefined ? stats[tag] + 1 : 1;
+    activeStreams[id] = readable;
 
-    const controlHandler = async () => {
+    // NATS handler
+    (async () => {
         const control = await connection.subscribe(`gx2.stream.${id}.a`, { max: 1 });
 
-        for await (const event of control)
-            if (event.data.length === 0) {
-                readable.on("data", chunk => connection.publishRaw(`gx2.stream.${id}.b`, chunk));
-                readable.on("close", () => {
-                    connection.publishRaw(`gx2.stream.${id}.b`);
-                    stats[tag]--;
-                });
-            }
+        const event = await getFirstItemFromAsyncIterable(control);
+        if (activeStreams[id] !== undefined && event.data.length === 0) {
+            // remove stream from the list
+            delete activeStreams[id];
+
+            // kickstart the stream
+            readable.on("data", chunk => connection.publishRaw(`gx2.stream.${id}.b`, chunk));
+            readable.on("close", () => {
+                connection.publishRaw(`gx2.stream.${id}.b`);
+                stats[tag]--;
+            });
+        }
+    })();
+
+    const result = {
+        $: "stream",
+        id
     };
 
-    controlHandler();
+    // get the port and addresses of the webserver
+    const addresses = webserver.getPort() ? getNetworkAddresses().map(address => `${address}:${webserver.getPort()}`) : undefined;
+    if (addresses) {
+        result.a = addresses;
+    }
 
-    return { $: "stream", id };
+    return result;
 }
 
 export function isStream(object) {
@@ -54,23 +74,43 @@ export function isStream(object) {
 }
 
 export async function getReadable(object) {
-    if (!isStream(object))
+    if (!isStream(object)) {
         return object;
+    }
+
+    // get stream via HTTP
+    if (object.a.length > 0) {
+        for (const address of object.a) {
+            try {
+                const uri = `http://${address}/!!_____stream/${object.id}`;
+                const response = await fetch(uri);
+
+                if (response.status === 200) {
+                    return Readable.fromWeb(response.body);
+                }
+            } catch {
+                // ignore errors
+            }
+        }
+    }
 
+    // get stream via NATS
     const readable = new Readable({ read: () => null });
     const subscription = await connection.subscribe(`gx2.stream.${object.id}.b`);
 
     const dataHandler = async () => {
-        for await (const event of subscription)
+        for await (const event of subscription) {
             try {
                 if (event.data.length === 0) {
                     readable.push(null);
                     subscription.drain();
-                } else
+                } else {
                     readable.push(event.data);
+                }
             } catch (e) {
-                console.error("Stream.getReadable.dataHandler.error:", e);
+                logger.error("Stream.getReadable.dataHandler.error:", e);
             }
+        }
     };
     dataHandler();
 
@@ -82,17 +122,18 @@ export async function getReadable(object) {
 
 export async function streamToBuffer(object) {
     let readable = object;
-    if (isStream(readable))
+    if (isStream(readable)) {
         readable = await getReadable(readable);
+    }
 
     return Buffer.concat(await readable.toArray());
 }
 
 export async function streamToString(object) {
     let readable = object;
-    if (isStream(readable))
+    if (isStream(readable)) {
         readable = await getReadable(readable);
+    }
 
     return Buffer.concat(await readable.toArray()).toString();
-}
-
+}

package/src/Util.js

@@ -3,6 +3,7 @@ import { URL, fileURLToPath } from "url";
 import { readFile } from "fs/promises";
 import { join } from "path";
 import { Transform } from "node:stream";
+import { networkInterfaces } from "os";
 import * as http from "http";
 import * as https from "https";
 import * as net from "net";
@@ -60,7 +61,6 @@ export const createServerAtPort = (port, pkg, handler) =>
     new Promise((resolve) => {
         const server = pkg.createServer(handler);
         server.on("error", (_error) => {
-            // console.log('error', error.message)
             resolve(null);
         });
         server.listen(port, () => {
@@ -78,14 +78,16 @@ export const createServerAtPort = (port, pkg, handler) =>
  * @returns 
  */
 export const createServerAtFreePort = async (pkg, handler, start = 30000, poolSize = 20000) => {
-    for (let port = start; port < start + poolSize; port++)
+    for (let port = start; port < start + poolSize; port++) {
         try {
             const result = await createServerAtPort(port, pkg, handler);
-            // console.log(port, '=', result)
-            if (result) return result;
+            if (result) {
+                return result;
+            }
         } catch {
             // silenty ignore errors
         }
+    }
 };
 
 /**
@@ -121,10 +123,11 @@ export const getFunctionParams = (fn) => {
     const endParenthesisPosition = code.indexOf(")");
     let params;
 
-    if (endParenthesisPosition != -1)
+    if (endParenthesisPosition != -1) {
         params = code.substring(code.indexOf("(") + 1, endParenthesisPosition);
-    else
+    } else {
         params = code.substring(0, code.indexOf("=>"));
+    }
 
     params = params
         // cleanup spaces
@@ -135,8 +138,9 @@ export const getFunctionParams = (fn) => {
     // remove potential default values
     for (let index = 0; index < params.length; index++) {
         const defaultValueAssignmentPosition = params[index].indexOf("=");
-        if (defaultValueAssignmentPosition != -1)
+        if (defaultValueAssignmentPosition != -1) {
             params[index] = params[index].substring(0, defaultValueAssignmentPosition - 1);
+        }
     }
 
     return params;
@@ -153,8 +157,10 @@ export const proxyHttp = (target, req, res) =>
         const protocol = req.protocol === "https" ? https : http;
         const proxyReq = protocol.request(remoteTarget, options, (proxyRes) => {
             res.status(proxyRes.statusCode);
-            for (const header in proxyRes.headers)
+            for (const header in proxyRes.headers) {
                 res.set(header, proxyRes.headers[header]);
+            }
+
             proxyRes.pipe(res);
         });
         proxyReq.on("error", (error) => reject(error));
@@ -207,4 +213,19 @@ export async function getFirstItemFromAsyncIterable(asyncIterable) {
     const iterator = asyncIterable[Symbol.asyncIterator]();
     const result = await iterator.next();
     return result.value;
+}
+
+export function getNetworkAddresses() {
+    const list = [];
+    const interfaces = networkInterfaces();
+
+    for (let interfaceAddresses of Object.values(interfaces)) {
+        for (let addressObject of interfaceAddresses) {
+            if (addressObject.family === "IPv4") {
+                list.push(addressObject.address);
+            }
+        }
+    }
+
+    return list;
 }

package/src/WebServer.js

@@ -1,11 +1,12 @@
 import "express-async-errors";
 import express, { Router } from "express";
 import expressWs from "express-ws";
-import { networkInterfaces } from "os";
 import { createServerAtFreePort, createServerAtPort, sleep } from "./Util.js";
 import * as http from "http";
 import { Service } from "./Service.js";
 import * as path from "path";
+import { logger } from "./Logger.js";
+import { activeStreams } from "./Stream.js";
 
 export const HEALTH_CHECK_ENDPOINT = "/pA4vY7fT9oG5aI8cA4yV3qW5fP9qR1vI";
 
@@ -16,12 +17,14 @@ export const ServeStatic = (root, options = {}) => {
     router.use((req, res, next) => {
         if (options.root) {
             // remove trailing slash
-            if (options.root.endsWith("/"))
+            if (options.root.endsWith("/")) {
                 options.root = options.root.slice(0, -1);
+            }
 
             // replace root prefix
-            if (req.url.startsWith(options.root))
+            if (req.url.startsWith(options.root)) {
                 req.url = req.url.replace(options.root, "");
+            }
         }
 
         next();
@@ -29,11 +32,12 @@ export const ServeStatic = (root, options = {}) => {
 
     router.use(express.static(root, options));
 
-    if (options.indexOn404)
+    if (options.indexOn404) {
         router.get("*", (req, res) => {
-            console.log(path.join(absoluteRoot, "index.html"));
+            logger.info(path.join(absoluteRoot, "index.html"));
             res.sendFile(path.join(absoluteRoot, "index.html"));
         });
+    }
 
     return router;
 };
@@ -47,31 +51,43 @@ class WebServer {
     #started = false;
 
     async start() {
-        if (this.#started)
-            return;
+        if (this.#started) { return; }
 
         this.#started = true;
 
-        let port, server;
+        let srv;
         if (process.env.LOCAL_PORT) {
-            ({ server, port } = await createServerAtPort(process.env.LOCAL_PORT, http, this.#app));
+            srv = await createServerAtPort(process.env.LOCAL_PORT, http, this.#app);
         } else {
-            ({ server, port } = await createServerAtFreePort(http, this.#app));
+            srv = await createServerAtFreePort(http, this.#app);
+        }
+
+        if (!srv) {
+            throw new Error("gx.webserver.start: unable to start");
         }
 
-        this.#server = server;
-        this.#port = port;
+        this.#server = srv.server;
+        this.#port = srv.port;
 
-        expressWs(this.#app, server);
+        expressWs(this.#app, srv.server);
+
+        // stream endpoint
+        this.#app.get("/!!_____stream/:id", (req, res) => {
+            const id = req.params.id;
+
+            if (activeStreams[id]) {
+                res.status(200);
+                activeStreams[id].pipe(res);
+                delete activeStreams[id];
+            } else {
+                res.status(404).send({ error: 404 });
+            }
+        });
 
         this.#app.get(HEALTH_CHECK_ENDPOINT, (req, res) => {
             res.send({ status: "healthy", services: Service.serviceClasses });
         });
 
-        // this.#app.use((req, res, next) => {
-        //     next()
-        // })
-
         // wait for 2 seconds and then set fall-through handler
         // this should provide more than enough time to start all the services
         setTimeout(() => {
@@ -88,23 +104,11 @@ class WebServer {
         this.#app.disable("x-powered-by");
         this.#app.disable("etag");
 
-        console.log(`gx.webserver.start: listening on http://127.0.0.1:${this.#port}`);
+        logger.info(`gx.webserver.start: listening on http://127.0.0.1:${this.#port}`);
 
         this.#ready = true;
     }
 
-    getAddresses() {
-        const list = [];
-        const interfaces = networkInterfaces();
-
-        for (let interfaceAddresses of Object.values(interfaces))
-            for (let addressObject of interfaceAddresses)
-                if (addressObject.family === "IPv4")
-                    list.push(addressObject.address);
-
-        return list;
-    }
-
     getPort() {
         return this.#port;
     }
@@ -118,14 +122,15 @@ class WebServer {
     async waitUntilReady() {
         await this.start();
 
-        while (!this.#ready)
+        while (!this.#ready) {
             await sleep(100);
+        }
     }
 
     stop() {
         if (this.#server) {
             this.#server.close();
-            console.log("gx.webserver.stop");
+            logger.info("gx.webserver.stop");
         }
     }
 

package/test/gateway.js

@@ -2,14 +2,14 @@ import { Gateway, Service } from "../exports.js";
 
 class TestService extends Service {
 
-    'GET /'(req, res) {
-        res.send('Hello World')
+    "GET /"(req, res) {
+        res.send("Hello World");
     }
 }
 
-TestService.start()
+TestService.start();
 Gateway.start({
     beforeRequest: (req, res) => {
-        res.set('X-Test', 'Test')
+        res.set("X-Test", "Test");
     }
-})
+});

package/test/stream.js

@@ -1,38 +1,43 @@
-import { randomBytes } from 'node:crypto'
-import { Stream, getReadable, connection } from 'geonix'
-import { createWriteStream, readFileSync } from 'node:fs'
-import { createHash } from 'node:crypto'
-import { pipeline } from 'node:stream/promises'
+import { randomBytes } from "node:crypto";
+import { Stream, getReadable, connection } from "geonix";
+import { createWriteStream, readFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { pipeline } from "node:stream/promises";
+import { webserver } from "../src/WebServer.js";
 
-await connection.waitUntilReady()
+await connection.waitUntilReady();
 
-const hash = data => createHash('sha512').update(data).digest('base64')
+const hash = data => createHash("sha512").update(data).digest("base64");
 
-const PAYLOAD_SIZE = 1024 * 1024 * 1024
-const TEMP_FILE = '/tmp/geonix.stream_test'
+const PAYLOAD_SIZE = 1024 * 1024 * 1024;
+const TEMP_FILE = "/tmp/geonix.stream_test";
 
-console.time('test')
+await webserver.start();
+
+console.time("test");
 try {
-    const payload = randomBytes(PAYLOAD_SIZE)
-    const sourceHash = hash(payload)
+    const payload = randomBytes(PAYLOAD_SIZE);
+    const sourceHash = hash(payload);
+
+    const stream = Stream(payload);
 
-    const source = await getReadable(Stream(payload))
-    const dest = createWriteStream(TEMP_FILE)
+    const source = await getReadable(stream);
+    const dest = createWriteStream(TEMP_FILE);
 
-    await pipeline(source, dest)
+    await pipeline(source, dest);
 
-    const check = readFileSync(TEMP_FILE)
-    const destHash = hash(check)
+    const check = readFileSync(TEMP_FILE);
+    const destHash = hash(check);
 
     if (sourceHash == destHash) {
-        console.log('MATCH')
+        console.log("MATCH");
     } else {
-        console.error('Destination does not match the source!')
-        console.log(payload)
-        console.log(check)
+        console.error("Destination does not match the source!");
+        console.log("P =", payload);
+        console.log("C =", check);
     }
 } catch (e) {
-    console.error(e)
+    console.error(e);
 } finally {
-    console.timeEnd('test')
+    console.timeEnd("test");
 }