geonix 1.20.0 → 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.
@@ -77,21 +85,27 @@ declare class Registry {
 export {};
 export function Remote(service: string, ...context: (string | Stream | Object)[]): string | Stream | Object;
 /**
+ * Send a request to a service
  *
- * @param {*} service
- * @param {*} method
- * @param {*} args
+ * @param {string} service
+ * @param {string} method
+ * @param {any[]} args
+ * @param {any[]} context
+ * @param {object} options
  * @returns
  */
-export function Request(service: any, method: any, args: any, context: any[] | undefined, options: any): Promise<any>;
+export function Request(service: string, method: string, args: any[], context: any[], options: object): Promise<any>;
 /**
+ * Send a request to a service
  *
- * @param {*} service
- * @param {*} method
- * @param {*} args
+ * @param {string} identifier
+ * @param {string} method
+ * @param {any[]} args
+ * @param {any[]} context
+ * @param {object} options
  * @returns
  */
-export function directRequest(identifier: any, method: any, args: any, context: any[] | undefined, options: any, service: any): Promise<any>;
+export function directRequest(identifier: string, method: string, args: any[], context: any[], options: object, service: any): Promise<any>;
 /**
  * Publish payload to a subject
  *
@@ -115,7 +129,6 @@ export function RequestOptions(options: any): RequestOptionsClass;
 export class Service {
     static serviceClasses: any[];
     static start(options?: {}): void;
-    static static(): void;
     connections: Map<any, any>;
     $createConnection(streamId: any): Promise<boolean>;
     $getEnv(): {
@@ -133,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
  *
@@ -146,12 +170,15 @@ 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
  * @returns
  */
 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;
@@ -170,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.0",
+    "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));
         }
     }
 
@@ -72,15 +74,17 @@ class Connection {
      * Wait for the connection to be safely closed
      */
     async waitUntilClosed() {
-        await this.#getConnection().closed();
+        // wait for all connections to be closed
+        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);
     }
 
@@ -88,8 +92,9 @@ class Connection {
      * Wait for the connection to be fully established
      */
     async waitUntilReady() {
-        while (!this.#ready)
+        while (!this.#ready) {
             await sleep(100);
+        }
     }
 
     /**
@@ -100,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);
     }
@@ -120,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);
     }
@@ -145,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) {
@@ -181,9 +190,7 @@ class Connection {
     async drain() {
         this.#draining = true;
 
-        for (let connection of this.#connections) {
-            await connection.drain();
-        }
+        await Promise.all(this.#connections.map(connection => connection.drain()));
     }
 
 }
@@ -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,27 +157,29 @@ 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;
-            for (let address of entry.a)
-                try {
-                    const ac = new AbortController();
-                    const timeout = setTimeout(() => ac.abort(), 500);
-                    const result = await (await fetch(`http://${address}${HEALTH_CHECK_ENDPOINT}`, { signal: ac.signal })).json();
-                    clearTimeout(timeout);
-                    if (result.status === "healthy" && result.services?.includes(entry.n)) {
-                        backend = address;
-                        console.log(`${entry.n}@${entry.v} (#${entry.i}) directly reachable @ ${address}`);
-                        break;
+            if (entry.a) {
+                for (let address of entry.a) {
+                    try {
+                        const ac = new AbortController();
+                        const timeout = setTimeout(() => ac.abort(), 500);
+                        const result = await (await fetch(`http://${address}${HEALTH_CHECK_ENDPOINT}`, { signal: ac.signal })).json();
+                        clearTimeout(timeout);
+                        if (result.status === "healthy" && result.services?.includes(entry.n)) {
+                            backend = address;
+                            logger.info(`${entry.n}@${entry.v} (#${entry.i}) directly reachable @ ${address}`);
+                            break;
+                        }
+                    } catch {
+                        // silently ignore errors
                     }
-                } catch {
-                    // silently ignore errors
                 }
+            }
 
             let proxy;
             if (!backend) {
@@ -188,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);
@@ -202,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() {
@@ -213,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;
@@ -288,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();
@@ -319,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;
@@ -357,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);
                         }
                     }
                 }
@@ -370,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
@@ -395,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;
     }