geonix 1.30.2 → 1.30.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "geonix",
-    "version": "1.30.2",
+    "version": "1.30.4",
     "type": "module",
     "description": "",
     "bin": {
@@ -34,4 +34,4 @@
         "eslint": "^10.1.0",
         "globals": "^17.4.0"
     }
-}
+}

package/src/Codec.js

@@ -30,4 +30,4 @@ export function decode(data) {
     } catch (e) {
         throw new Error(`Codec.decode: ${e.message}`, { cause: e });
     }
-}
+}

package/src/Connection.js

@@ -10,7 +10,7 @@ import { encryptPayload, decryptPayload, encryptSubject, wrapSubscription } from
 const CONNECTION_TIMEOUT = 10000;
 
 const defaultRequestOptions = {
-    timeout: 300000
+    timeout: 300000,
 };
 
 const DEFAULT_CONNECTION_COUNT = 1;
@@ -21,7 +21,16 @@ const defaultConnectionOptions = {
     debug: (process.env.GX_TRANSPORT_DEBUG || process.env.TRANSPORT_DEBUG) === "true",
     maxReconnectAttempts: 30,
     pingInterval: 30000,
-    waitOnFirstConnect: true
+    waitOnFirstConnect: true,
+};
+
+const TRANSPORT_TIMEOUT = 60_000;
+const WATCHDOG_INTERVAL = 1000;
+
+// env read via a function so tests can set GX_TRANSPORT_TIMEOUT after this module is imported
+const getTransportTimeout = () => {
+    const raw = parseInt(process.env.GX_TRANSPORT_TIMEOUT, 10);
+    return Number.isFinite(raw) ? raw : TRANSPORT_TIMEOUT;
 };
 // -------------------------------------------------------------------------------------------------
 
@@ -32,12 +41,13 @@ const defaultConnectionOptions = {
  * encryption are activated by setting the `GX_SECRET` environment variable.
  */
 class Connection {
-
     #draining = false;
     #closed = false;
     #ready = false;
     #connections = [];
     #connectionRoundRobin = 0;
+    #disconnectedSince = Date.now();
+    #watchdogInterval = null;
 
     #getConnection() {
         return this.#connections[this.#connectionRoundRobin++ % this.#connections.length];
@@ -54,20 +64,52 @@ class Connection {
     async start(transport = process.env.GX_TRANSPORT || process.env.TRANSPORT || "nats://localhost") {
         const { connections: _connectionCount, ...natsOptions } = {
             ...defaultConnectionOptions,
-            ...parseURL(transport)
+            ...parseURL(transport),
         };
         const connectionCount = parseInt(_connectionCount) || DEFAULT_CONNECTION_COUNT;
 
+        this.#startWatchdog();
+
         for (let i = 0; i < connectionCount; i++) {
             this.#connections.push(await connect(natsOptions));
         }
 
+        this.#disconnectedSince = null;
+
         logger.info("gx.connection.connected");
 
         this.#ready = true;
 
         this.monitorStatus();
-        this.waitUntilClosed().catch(e => logger.error("gx.connection.waitUntilClosed:", e));
+        this.waitUntilClosed().catch((e) => logger.error("gx.connection.waitUntilClosed:", e));
+    }
+
+    // Polls the disconnect timestamp; exits the process if the transport has been
+    // unreachable longer than GX_TRANSPORT_TIMEOUT (default 60s, 0 disables).
+    #startWatchdog() {
+        if (this.#watchdogInterval) {
+            return;
+        }
+
+        this.#watchdogInterval = setInterval(() => {
+            const limit = getTransportTimeout();
+            if (limit === 0) {
+                return;
+            }
+            if (this.#disconnectedSince === null) {
+                return;
+            }
+
+            const elapsed = Date.now() - this.#disconnectedSince;
+            if (elapsed >= limit) {
+                logger.error(
+                    `gx.connection: transport unreachable for ${Math.round(elapsed / 1000)}s (limit ${limit}ms), exiting`,
+                );
+                process.exit(1);
+            }
+        }, WATCHDOG_INTERVAL);
+
+        this.#watchdogInterval.unref?.();
     }
 
     /**
@@ -78,9 +120,17 @@ class Connection {
         for (const conn of this.#connections) {
             (async () => {
                 for await (const event of conn.status()) {
+                    if (event.type === "disconnect") {
+                        if (this.#disconnectedSince === null) {
+                            this.#disconnectedSince = Date.now();
+                        }
+                    } else if (event.type === "reconnect") {
+                        this.#disconnectedSince = null;
+                    }
+
                     logger.debug("gx.connection.status", JSON.stringify(event));
                 }
-            })().catch(e => logger.error("gx.connection.status:", e));
+            })().catch((e) => logger.error("gx.connection.status:", e));
         }
     }
 
@@ -92,11 +142,16 @@ class Connection {
      */
     async waitUntilClosed() {
         // wait for all connections to be closed
-        await Promise.all(this.#connections.map(connection => connection.closed()));
+        await Promise.all(this.#connections.map((connection) => connection.closed()));
 
         this.#closed = true;
         logger.info("gx.connection.closed");
 
+        if (this.#watchdogInterval) {
+            clearInterval(this.#watchdogInterval);
+            this.#watchdogInterval = null;
+        }
+
         webserver.stop();
 
         await sleep(5000);
@@ -118,9 +173,9 @@ class Connection {
 
     /**
      * Publish JSON
-     * 
-     * @param {string} subject 
-     * @param {object} json 
+     *
+     * @param {string} subject
+     * @param {object} json
      * @returns void
      */
     async publish(subject, json) {
@@ -150,21 +205,24 @@ class Connection {
             return;
         }
 
-        await this.#getConnection().publish(encryptSubject(subject), encryptPayload(data != null ? Buffer.from(data) : Buffer.alloc(0)));
+        await this.#getConnection().publish(
+            encryptSubject(subject),
+            encryptPayload(data != null ? Buffer.from(data) : Buffer.alloc(0)),
+        );
     }
 
     /**
      * Request/Reply pattern on top of pub/sub
-     * 
-     * @param {string} subject 
-     * @param {object} json 
-     * @param {object} options 
+     *
+     * @param {string} subject
+     * @param {object} json
+     * @param {object} options
      * @returns any
      */
     async request(subject, json, opts = {}) {
         const options = {
             ...defaultRequestOptions,
-            ...opts
+            ...opts,
         };
 
         const respondTo = `gx2.r.${picoid(16)}`;
@@ -235,9 +293,8 @@ class Connection {
     async drain() {
         this.#draining = true;
 
-        await Promise.all(this.#connections.map(connection => connection.drain()));
+        await Promise.all(this.#connections.map((connection) => connection.drain()));
     }
-
 }
 
 /**
@@ -247,7 +304,7 @@ class Connection {
  * @type {Connection}
  */
 export const connection = new Connection();
-connection.start().catch(e => {
+connection.start().catch((e) => {
     logger.error("gx.connection.start:", e);
     process.exit(1);
 });

package/src/Crypto.js

@@ -3,7 +3,11 @@ import { createCipheriv, createDecipheriv, createHash, createHmac, randomBytes }
 const _secret = process.env.GX_SECRET || null;
 
 // Subject key is derived separately so HMAC-subject and AES-payload never share key material.
-const _subjectKey = _secret ? createHash("sha256").update(_secret + "\x00subject").digest() : null;
+const _subjectKey = _secret
+    ? createHash("sha256")
+          .update(_secret + "\x00subject")
+          .digest()
+    : null;
 
 /**
  * AES-256-GCM key derived from `GX_SECRET`, or `null` when encryption is disabled.
@@ -11,7 +15,11 @@ const _subjectKey = _secret ? createHash("sha256").update(_secret + "\x00subject
  *
  * @type {Buffer|null}
  */
-export const _payloadKey = _secret ? createHash("sha256").update(_secret + "\x00payload").digest() : null;
+export const _payloadKey = _secret
+    ? createHash("sha256")
+          .update(_secret + "\x00payload")
+          .digest()
+    : null;
 
 /**
  * Encrypts `data` with AES-256-GCM using {@link _payloadKey}. Returns `data` unchanged when
@@ -21,7 +29,9 @@ export const _payloadKey = _secret ? createHash("sha256").update(_secret + "\x00
  * @returns {Buffer}
  */
 export function encryptPayload(data) {
-    if (!_payloadKey) { return data; }
+    if (!_payloadKey) {
+        return data;
+    }
     const buf = data != null ? Buffer.from(data) : Buffer.alloc(0);
     const iv = randomBytes(12);
     const cipher = createCipheriv("aes-256-gcm", _payloadKey, iv);
@@ -42,7 +52,9 @@ export function encryptPayload(data) {
  * @returns {Buffer}
  */
 export function decryptPayload(data) {
-    if (!_payloadKey) { return data; }
+    if (!_payloadKey) {
+        return data;
+    }
     const buf = Buffer.from(data);
     const decipher = createDecipheriv("aes-256-gcm", _payloadKey, buf.subarray(0, 12));
     decipher.setAuthTag(buf.subarray(12, 28));
@@ -64,10 +76,12 @@ export function encryptSubject(subject) {
         return subject;
     }
 
-    return subject.split(".").map(seg =>
-        (seg === "*" || seg === ">") ? seg
-            : createHmac("sha256", _subjectKey).update(seg).digest("hex").slice(0, 32)
-    ).join(".");
+    return subject
+        .split(".")
+        .map((seg) =>
+            seg === "*" || seg === ">" ? seg : createHmac("sha256", _subjectKey).update(seg).digest("hex").slice(0, 32),
+        )
+        .join(".");
 }
 
 /**
@@ -94,7 +108,7 @@ export function wrapSubscription(sub) {
                     }
 
                     return { value: { ...value, data: decryptPayload(value.data) }, done: false };
-                }
+                },
             };
         },
         drain: () => sub.drain(),

package/src/Gateway.js

@@ -15,12 +15,14 @@ const MAX_SESSIONS = 16384;
 // Real client IP — checks well-known CDN/proxy headers before falling back to socket address
 function getClientIp(req) {
     const header =
-        req.headers["cf-connecting-ip"] ||       // Cloudflare
-        req.headers["true-client-ip"] ||          // Cloudflare Enterprise / Akamai
-        req.headers["x-real-ip"] ||               // nginx
-        req.headers["x-forwarded-for"];           // standard (may be comma-separated list)
+        req.headers["cf-connecting-ip"] || // Cloudflare
+        req.headers["true-client-ip"] || // Cloudflare Enterprise / Akamai
+        req.headers["x-real-ip"] || // nginx
+        req.headers["x-forwarded-for"]; // standard (may be comma-separated list)
 
-    if (header) { return header.split(",")[0].trim(); }
+    if (header) {
+        return header.split(",")[0].trim();
+    }
     return req.socket?.remoteAddress || "unknown";
 }
 
@@ -39,12 +41,12 @@ const stats = {
     requests: 0,
     proxied: 0,
     proxied_over_nats: 0,
-    debug_requests: 0
+    debug_requests: 0,
 };
 
 const defaultOpts = {
-    beforeRequest: (_req, _res) => { },
-    afterRequest: (_req, _res) => { }
+    beforeRequest: (_req, _res) => {},
+    afterRequest: (_req, _res) => {},
 };
 
 /**
@@ -53,7 +55,6 @@ const defaultOpts = {
  * dynamically as services join and leave the bus.
  */
 export class Gateway {
-
     /**
      * Creates and starts a new Gateway instance.
      *
@@ -85,7 +86,7 @@ export class Gateway {
 
         this.#opts = { ...this.#opts, ...opts };
 
-        this.#start().catch(e => logger.error("gx.gateway.start:", e));
+        this.#start().catch((e) => logger.error("gx.gateway.start:", e));
     }
 
     async #start(port = 8080) {
@@ -179,7 +180,7 @@ export class Gateway {
         this.#api.all("*", (req, res) => {
             res.status(404).send({
                 error: 404,
-                source: "gw"
+                source: "gw",
             });
         });
 
@@ -253,7 +254,7 @@ export class Gateway {
             return true;
         };
 
-        entries = (await Promise.all(entries.map(processEntry))).filter(result => result === true);
+        entries = (await Promise.all(entries.map(processEntry))).filter((result) => result === true);
 
         if (entries.length > 0) {
             this.#rebuildRouter = true;
@@ -285,7 +286,7 @@ export class Gateway {
         });
 
         router.get("/services", (req, res) => {
-            const services = Object.values(registry.getEntries()).map(e => (`${e.n}@${e.v}`));
+            const services = Object.values(registry.getEntries()).map((e) => `${e.n}@${e.v}`);
             services.sort();
             res.send(services);
         });
@@ -312,11 +313,11 @@ export class Gateway {
                 node: {
                     version: process.version,
                     platform: process.platform,
-                    arch: process.arch
+                    arch: process.arch,
                 },
                 mem: process.memoryUsage(),
                 rss: process.memoryUsage.rss(),
-                cpu: process.cpuUsage()
+                cpu: process.cpuUsage(),
             });
         });
 
@@ -341,19 +342,21 @@ 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().catch(e => logger.error("nats.proxy.dataLoop:", e));
+            dataLoop().catch((e) => logger.error("nats.proxy.dataLoop:", e));
         }
     }
 
     /**
      * Proxies websocket connection
-     * 
-     * @param {string} target 
-     * @param {Readable} inbound 
-     * @param {Request} req 
+     *
+     * @param {string} target
+     * @param {Readable} inbound
+     * @param {Request} req
      */
     #proxyWebsocket(target, inbound, req) {
         try {
@@ -366,7 +369,7 @@ export class Gateway {
 
             backend.on("open", () => {
                 backend.on("message", (data, isBinary) => inbound.send(isBinary ? data : data.toString()));
-                inbound.on("message", data => backend.send(data));
+                inbound.on("message", (data) => backend.send(data));
 
                 backend.on("close", () => inbound.close());
                 inbound.on("close", () => backend.close());
@@ -398,18 +401,22 @@ export class Gateway {
                     ? `127.0.0.1:${proxy.port}`
                     : entry.a?.[Math.floor(Math.random() * entry.a.length)];
 
-                if (!backendAddr) { continue; }
+                if (!backendAddr) {
+                    continue;
+                }
 
                 // generate global endpoint list
                 for (let e of entry.m) {
                     const endpointMatch = endpointMatcher.exec(e);
                     if (endpointMatch) {
                         const endpoint = endpointMatch.groups;
-                        const parsed = endpoint.options ? Object.fromEntries(new URLSearchParams(endpoint.options)) : {};
+                        const parsed = endpoint.options
+                            ? Object.fromEntries(new URLSearchParams(endpoint.options))
+                            : {};
                         const parsedOrder = parseInt(parsed.order, 10);
                         let options = {
                             ...parsed,
-                            order: Number.isNaN(parsedOrder) ? 100 : parsedOrder
+                            order: Number.isNaN(parsedOrder) ? 100 : parsedOrder,
                         };
 
                         try {
@@ -418,7 +425,7 @@ export class Gateway {
                                 version: semver.coerce(entry.v).version,
                                 options,
                                 endpoint,
-                                backend: [backendAddr]
+                                backend: [backendAddr],
                             });
                         } catch (e) {
                             logger.error("gateway.buildRouter.error:", entry);
@@ -435,7 +442,10 @@ export class Gateway {
                 const url = `${endpoints[index].endpoint.verb} ${endpoints[index].endpoint.url}`;
 
                 for (let n = 0; n < index; n++) {
-                    if (`${endpoints[n].endpoint.verb} ${endpoints[n].endpoint.url}` === url && endpoints[n].version === version) {
+                    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;
@@ -509,5 +519,4 @@ export class Gateway {
         this.#isActive = false;
         clearInterval(this.#rebuildRouterInterval);
     }
-
 }

package/src/Logger.js

@@ -5,12 +5,16 @@ const LEVEL = LEVELS[process.env.GX_LOG_LEVEL] ?? LEVELS.info;
 const FORMAT = process.env.GX_LOG_FORMAT === "json" ? "json" : "text";
 
 const defaultLoggerOptions = {
-    timestamp: true
+    timestamp: true,
 };
 
 function serialize(val) {
-    if (val instanceof Error) { return val.stack || val.message; }
-    if (typeof val === "object" && val !== null) { return JSON.stringify(val); }
+    if (val instanceof Error) {
+        return val.stack || val.message;
+    }
+    if (typeof val === "object" && val !== null) {
+        return JSON.stringify(val);
+    }
     return String(val);
 }
 
@@ -22,7 +26,6 @@ function serialize(val) {
  * The output format is controlled by `GX_LOG_FORMAT` (`text` | `json`, default `text`).
  */
 export class Logger {
-
     #options = defaultLoggerOptions;
     #level = LEVEL;
     #format = FORMAT;
@@ -46,10 +49,17 @@ export class Logger {
     #log(level, ...args) {
         const stream = level === "error" ? process.stderr : process.stdout;
         if (this.#format === "json") {
-            stream.write(JSON.stringify({ time: new Date().toISOString(), level, msg: args.map(serialize).join(" ") }) + "\n");
+            stream.write(
+                JSON.stringify({ time: new Date().toISOString(), level, msg: args.map(serialize).join(" ") }) + "\n",
+            );
         } else {
             const ts = this.#options.timestamp ? new Date().toISOString() : undefined;
-            stream.write([ts, TAGS[level], ...args].filter($ => $ !== undefined).map(serialize).join(" ") + "\n");
+            stream.write(
+                [ts, TAGS[level], ...args]
+                    .filter(($) => $ !== undefined)
+                    .map(serialize)
+                    .join(" ") + "\n",
+            );
         }
     }
 
@@ -104,7 +114,6 @@ export class Logger {
     setFormat(format) {
         this.#format = format === "json" ? "json" : "text";
     }
-
 }
 
 /**

package/src/Registry.js

@@ -17,7 +17,6 @@ const GARBAGE_COLLECTOR_INTERVAL = 500;
  * @extends EventEmitter
  */
 class Registry extends EventEmitter {
-
     #isActive = false;
     #registry = {};
     #byIdentifier = new Map();
@@ -25,15 +24,15 @@ class Registry extends EventEmitter {
     constructor() {
         super();
 
-        this.#start().catch(e => logger.error("registry.start:", e));
+        this.#start().catch((e) => logger.error("registry.start:", e));
     }
 
     async #start() {
         this.#isActive = true;
         await connection.waitUntilReady();
 
-        this.#beaconListener().catch(e => logger.error("registry.beaconListener:", e));
-        this.#garbageCollector().catch(e => logger.error("registry.garbageCollector:", e));
+        this.#beaconListener().catch((e) => logger.error("registry.beaconListener:", e));
+        this.#garbageCollector().catch((e) => logger.error("registry.garbageCollector:", e));
     }
 
     /**
@@ -69,14 +68,17 @@ class Registry extends EventEmitter {
             let firstFound = false;
             const onFirstHealthy = () => {
                 if (!firstFound) {
-                    firstFound = true; resolveFirst();
+                    firstFound = true;
+                    resolveFirst();
                 }
             };
 
             // all checks run in parallel; background ones push into data.a,
             // which is the same array reference spread into the registry entry below
             // resolve promiseFirst when all checks are done so we don't wait on the timeout
-            Promise.all(allAddresses.map(a => this.#checkHealth(a, data.a, onFirstHealthy))).then(() => resolveFirst());
+            Promise.all(allAddresses.map((a) => this.#checkHealth(a, data.a, onFirstHealthy))).then(() =>
+                resolveFirst(),
+            );
 
             try {
                 await withTimeout(promiseFirst, 5000);
@@ -87,7 +89,7 @@ class Registry extends EventEmitter {
 
         this.#registry[data.i] = {
             ...data,
-            timeout: Date.now() + REGISTRY_ENTRY_TIMEOUT
+            timeout: Date.now() + REGISTRY_ENTRY_TIMEOUT,
         };
 
         const nameVersion = `${data.n}@${data.v}`;
@@ -124,7 +126,7 @@ class Registry extends EventEmitter {
             }
 
             // new service — dispatch registration without awaiting so the beacon loop stays unblocked
-            this.#registerService(data).catch(e => logger.error("registry.registerService:", e));
+            this.#registerService(data).catch((e) => logger.error("registry.registerService:", e));
         }
     }
 
@@ -144,7 +146,9 @@ class Registry extends EventEmitter {
                     const set = this.#byIdentifier.get(nameVersion);
                     if (set) {
                         set.delete(entry.i);
-                        if (set.size === 0) { this.#byIdentifier.delete(nameVersion); }
+                        if (set.size === 0) {
+                            this.#byIdentifier.delete(nameVersion);
+                        }
                     }
                     this.#byIdentifier.delete(entry.i);
 
@@ -174,8 +178,11 @@ class Registry extends EventEmitter {
      */
     getEntriesForIdentifier(identifier) {
         const ids = this.#byIdentifier.get(identifier);
-        if (!ids) { return []; }
-        return [...ids].map(i => this.#registry[i]).filter(Boolean);
+        if (!ids) {
+            return [];
+        }
+
+        return [...ids].map((i) => this.#registry[i]).filter(Boolean);
     }
 
     /**
@@ -215,7 +222,6 @@ class Registry extends EventEmitter {
             return `${matches[0].n}@${matches[0].v}`;
         }
     }
-
 }
 
 /**
@@ -223,4 +229,4 @@ class Registry extends EventEmitter {
  *
  * @type {Registry}
  */
-export const registry = new Registry();
+export const registry = new Registry();

package/src/Remote.js

@@ -10,12 +10,16 @@ import { Request } from "./Request.js";
  * @param {...any} context - Optional context values forwarded to the remote method.
  * @returns {Proxy} A proxy whose properties are async functions that call the remote service.
  */
-export const Remote = (service, ...context) => new Proxy({}, {
-    get: (_target, method) => {
-        if (typeof method !== "string" || method === "then") {
-            return undefined;
-        }
+export const Remote = (service, ...context) =>
+    new Proxy(
+        {},
+        {
+            get: (_target, method) => {
+                if (typeof method !== "string" || method === "then") {
+                    return undefined;
+                }
 
-        return async (...args) => Request(service, method, args, context);
-    }
-});
+                return async (...args) => Request(service, method, args, context);
+            },
+        },
+    );

package/src/Request.js

@@ -23,7 +23,7 @@ function waitForIdentifier(name, version, id, timeout) {
         return Promise.resolve(found);
     }
 
-    return new Promise(resolve => {
+    return new Promise((resolve) => {
         const timer = setTimeout(() => {
             registry.removeListener("added", onAdded);
             resolve(null);
@@ -109,11 +109,15 @@ export async function directRequest(identifier, method, args, context, options,
 
             let httpResponse;
             try {
-                const res = await fetchWithTimeout(url, {
-                    method: "POST",
-                    headers: { "content-type": contentType },
-                    body: fetchBody,
-                }, options?.httpTimeout ?? 5000);
+                const res = await fetchWithTimeout(
+                    url,
+                    {
+                        method: "POST",
+                        headers: { "content-type": contentType },
+                        body: fetchBody,
+                    },
+                    options?.httpTimeout ?? 5000,
+                );
                 if (res.ok) {
                     httpResponse = _payloadKey
                         ? JSON.parse(decryptPayload(Buffer.from(await res.arrayBuffer())))
@@ -124,7 +128,9 @@ export async function directRequest(identifier, method, args, context, options,
             }
 
             if (httpResponse) {
-                if (httpResponse.e) { throw Error(`Request: remote error: ${httpResponse.e}`); }
+                if (httpResponse.e) {
+                    throw Error(`Request: remote error: ${httpResponse.e}`);
+                }
                 if (isStream(httpResponse.r)) {
                     return JSON.parse(await streamToString(httpResponse.r));
                 }
@@ -142,19 +148,29 @@ export async function directRequest(identifier, method, args, context, options,
                 m: method,
                 a: args,
                 c: context,
-                o: originator
+                o: originator,
             },
-            options);
+            options,
+        );
 
         // automatically process streamed response
         if (isStream(response)) {
             response = JSON.parse(await streamToString(response));
         }
     } catch (e) {
-        logger.debug("GxError: directRequest", inspect({
-            originator, service: service ?? identifier, method, args, context, options,
-            error: e, duration: Date.now() - requestBegin
-        }));
+        logger.debug(
+            "GxError: directRequest",
+            inspect({
+                originator,
+                service: service ?? identifier,
+                method,
+                args,
+                context,
+                options,
+                error: e,
+                duration: Date.now() - requestBegin,
+            }),
+        );
 
         throw e;
     }
@@ -199,4 +215,4 @@ export async function Subscribe(subject, callback) {
     for await (const event of subscription) {
         callback(event.data);
     }
-}
+}

package/src/Service.js

@@ -1,5 +1,15 @@
 import { connection } from "./Connection.js";
-import { picoid, sleep, hash, getSecondsSinceMidnight, OverlayObject, GeonixVersion, getFirstItemFromAsyncIterable, getNetworkAddresses, deepMerge } from "./Util.js";
+import {
+    picoid,
+    sleep,
+    hash,
+    getSecondsSinceMidnight,
+    OverlayObject,
+    GeonixVersion,
+    getFirstItemFromAsyncIterable,
+    getNetworkAddresses,
+    deepMerge,
+} from "./Util.js";
 import { webserver } from "./WebServer.js";
 import { createConnection } from "net";
 import { EOL } from "os";
@@ -18,7 +28,7 @@ const getInactivityTimeout = () => parseInt(process.env.GX_INACTIVITY_TIMEOUT) |
 
 const protectedMethodNames = ["constructor", "onStart"];
 const endpointMatcher = /^((?<options>.+)\|)?(?<verb>WS|SUB|GET|POST|PATCH|PUT|DELETE|HEAD|OPTIONS|ALL)\s(?<url>.*)/;
-const isEndpointFilter = methodName => endpointMatcher.test(methodName);
+const isEndpointFilter = (methodName) => endpointMatcher.test(methodName);
 const ERROR_BEGIN_DELIMITER = "-".repeat(10);
 const ERROR_END_DELIMITER = "-".repeat(40);
 
@@ -33,9 +43,9 @@ const defaultServiceOptions = {
     middleware: {
         json: true,
         raw: true,
-        cookies: true
+        cookies: true,
     },
-    fullBeacon: true
+    fullBeacon: true,
 };
 
 /**
@@ -43,7 +53,6 @@ const defaultServiceOptions = {
  * the service on the NATS bus, expose HTTP endpoints, and begin sending beacons to the registry.
  */
 export class Service {
-
     /**
      * Creates a new instance of the subclass and starts it on the NATS bus.
      *
@@ -52,10 +61,10 @@ export class Service {
      */
     static start(options = {}) {
         const instance = new this();
-        instance.#start(options).catch(e => logger.error("gx.service.start:", e));
+        instance.#start(options).catch((e) => logger.error("gx.service.start:", e));
     }
 
-    // ---------------------------------------------------------------------------------------------    
+    // ---------------------------------------------------------------------------------------------
 
     #isActive = false;
     #me = {};
@@ -78,7 +87,10 @@ export class Service {
         const lineMap = new Map();
         for (const name of fields) {
             const quoted = JSON.stringify(name);
-            lineMap.set(name, serviceSource.findIndex(line => line.includes(quoted)));
+            lineMap.set(
+                name,
+                serviceSource.findIndex((line) => line.includes(quoted)),
+            );
         }
         fields.sort((a, b) => lineMap.get(a) - lineMap.get(b));
 
@@ -90,15 +102,21 @@ export class Service {
             // name
             n: options.name ?? this.constructor.name,
             // version
-            v: process.env.GX_VERSION || process.env.VERSION || process.env.version || options?.version || this.version || `999.999.${getSecondsSinceMidnight()}`,
+            v:
+                process.env.GX_VERSION ||
+                process.env.VERSION ||
+                process.env.version ||
+                options?.version ||
+                this.version ||
+                `999.999.${getSecondsSinceMidnight()}`,
             // methods
             m: fields
-                .filter(methodName => !protectedMethodNames.includes(methodName))
-                .filter(methodName => !methodName.startsWith("$")),
+                .filter((methodName) => !protectedMethodNames.includes(methodName))
+                .filter((methodName) => !methodName.startsWith("$")),
             // geonix version
             gx: GeonixVersion,
             // IP addresses
-            a: getNetworkAddresses().map(address => `${address}:${webserver.getPort()}`)
+            a: getNetworkAddresses().map((address) => `${address}:${webserver.getPort()}`),
         };
 
         // check if method takes context as first argument
@@ -106,21 +124,20 @@ export class Service {
             const method = this[methodName];
             this.#methodTakesContext.set(
                 method,
-                method.toString()?.match(/\((?<args>.*)\)/)?.groups?.args.startsWith("$")
+                method
+                    .toString()
+                    ?.match(/\((?<args>.*)\)/)
+                    ?.groups?.args.startsWith("$"),
             );
         }
 
-        this.#beacon()
-            .catch(e => logger.error("gx.beacon:", e));
+        this.#beacon().catch((e) => logger.error("gx.beacon:", e));
 
-        this.#callListener(`${this.#me.n}@${this.#me.v}`)
-            .catch(e => logger.error("gx.queueListener:", e));
+        this.#callListener(`${this.#me.n}@${this.#me.v}`).catch((e) => logger.error("gx.queueListener:", e));
 
-        this.#callListener(this.#me.i)
-            .catch(e => logger.error("gx.directListener:", e));
+        this.#callListener(this.#me.i).catch((e) => logger.error("gx.directListener:", e));
 
-        this.#webserver()
-            .catch(e => logger.error("gx.webserver:", e));
+        this.#webserver().catch((e) => logger.error("gx.webserver:", e));
 
         logger.info("gx.service.start", this.#me.n, this.#me.v);
 
@@ -141,7 +158,7 @@ export class Service {
     async #beacon() {
         while (this.#isActive) {
             const payload = this.#options.fullBeacon ? this.#me : { i: this.#me.i };
-            connection.publish("gx2.beacon", payload).catch(e => logger.warn("beacon.publish:", e));
+            connection.publish("gx2.beacon", payload).catch((e) => logger.warn("beacon.publish:", e));
             await sleep(BEACON_INTERVAL);
         }
     }
@@ -168,11 +185,10 @@ export class Service {
 
     /**
      * Register local endpoints with express instance
-     * @returns 
+     * @returns
      */
     async #webserver() {
-        const endpoints = this.#me.m
-            .filter(isEndpointFilter);
+        const endpoints = this.#me.m.filter(isEndpointFilter);
 
         const router = webserver.router();
 
@@ -181,7 +197,9 @@ export class Service {
         router.post(`/!!_gx/rpc/${hash(this.#me.i)}`, raw, async (req, res) => {
             const body = _payloadKey
                 ? JSON.parse(decryptPayload(req.body))
-                : (Buffer.isBuffer(req.body) ? JSON.parse(req.body.toString()) : req.body);
+                : Buffer.isBuffer(req.body)
+                  ? JSON.parse(req.body.toString())
+                  : req.body;
             await this.#onCall(body, (result) => {
                 const payload = Buffer.from(JSON.stringify(result));
                 if (_payloadKey) {
@@ -214,7 +232,7 @@ export class Service {
             let { verb, url: uri } = endpointMatcher.exec(endpoint)?.groups || {};
             verb = verb.toLowerCase();
 
-            let handlers = (Array.isArray(this[endpoint]) ? this[endpoint] : [this[endpoint]]);
+            let handlers = Array.isArray(this[endpoint]) ? this[endpoint] : [this[endpoint]];
 
             const handlersBefore = this.#options?.handlers?.before ?? [];
             const handlersAfter = this.#options?.handlers?.after ?? [];
@@ -232,7 +250,14 @@ export class Service {
                     // handlersBefore run as route-scoped middleware before the upgrade;
                     // handlersAfter does not apply to WebSocket connections.
                     if (handlersBefore.length > 0) {
-                        router.use(uri, ...handlersBefore.map(h => (...args) => h.apply(this, args)));
+                        router.use(
+                            uri,
+                            ...handlersBefore.map(
+                                (h) =>
+                                    (...args) =>
+                                        h.apply(this, args),
+                            ),
+                        );
                     }
                     router.ws(uri, this[endpoint].bind(this));
                     break;
@@ -258,14 +283,14 @@ export class Service {
                 handler(event.data);
             }
         };
-        processor().catch(e => logger.error("$sub.processor:", e));
+        processor().catch((e) => logger.error("$sub.processor:", e));
     }
 
     /**
      * Handle individual call
-     * @param {Object} call 
-     * @param {Function} respond 
-     * @returns 
+     * @param {Object} call
+     * @param {Function} respond
+     * @returns
      */
     async #onCall(call, respond) {
         const { m: methodName, a: args, c: context, o: caller } = call;
@@ -302,7 +327,7 @@ export class Service {
 
         this.#connections.set(streamId, {
             client,
-            sub: ingress
+            sub: ingress,
         });
 
         const cleanup = () => {
@@ -338,8 +363,11 @@ export class Service {
             cleanup();
         };
 
-        incomingLoop().catch(e => { logger.error("$createConnection.incomingLoop:", e); cleanup(); });
-        controlLoop().catch(e => logger.error("$createConnection.controlLoop:", e));
+        incomingLoop().catch((e) => {
+            logger.error("$createConnection.incomingLoop:", e);
+            cleanup();
+        });
+        controlLoop().catch((e) => logger.error("$createConnection.controlLoop:", e));
 
         return true;
     }
@@ -350,11 +378,11 @@ export class Service {
             node: {
                 version: process.version,
                 platform: process.platform,
-                arch: process.arch
+                arch: process.arch,
             },
             mem: process.memoryUsage(),
             rss: process.memoryUsage.rss(),
-            cpu: process.cpuUsage()
+            cpu: process.cpuUsage(),
         };
     }
 
@@ -369,5 +397,4 @@ export class Service {
     $stop() {
         this.#isActive = false;
     }
-
-}
+}

package/src/Stream.js

@@ -52,7 +52,7 @@ export function Stream(data) {
 
         const event = await Promise.race([
             getFirstItemFromAsyncIterable(control),
-            new Promise(resolve => setTimeout(() => resolve(null), getStreamTimeout()))
+            new Promise((resolve) => setTimeout(() => resolve(null), getStreamTimeout())),
         ]);
 
         if (!event) {
@@ -68,20 +68,22 @@ export function Stream(data) {
             delete activeStreams[id];
 
             // kickstart the stream
-            readable.on("data", chunk => connection.publishRaw(`gx2.stream.${id}.b`, chunk));
+            readable.on("data", (chunk) => connection.publishRaw(`gx2.stream.${id}.b`, chunk));
             readable.on("close", () => {
                 connection.publishRaw(`gx2.stream.${id}.b`);
             });
         }
-    })().catch(e => logger.error("stream.nats.handler:", e));
+    })().catch((e) => logger.error("stream.nats.handler:", e));
 
     const result = {
         $: "stream",
-        id
+        id,
     };
 
     // get the port and addresses of the webserver
-    const addresses = webserver.getPort() ? getNetworkAddresses().map(address => `${address}:${webserver.getPort()}`) : undefined;
+    const addresses = webserver.getPort()
+        ? getNetworkAddresses().map((address) => `${address}:${webserver.getPort()}`)
+        : undefined;
     if (addresses) {
         result.a = addresses;
     }
@@ -151,7 +153,11 @@ export async function getReadable(object) {
             }
         }
     };
-    dataHandler().catch(e => { logger.error("stream.dataHandler:", e); subscription.unsubscribe(); readable.destroy(); });
+    dataHandler().catch((e) => {
+        logger.error("stream.dataHandler:", e);
+        subscription.unsubscribe();
+        readable.destroy();
+    });
 
     // kickstart remote stream with a blank message
     await connection.publishRaw(`gx2.stream.${object.id}.a`);

package/src/Util.js

@@ -14,22 +14,22 @@ import { tmpdir } from "os";
 
 /**
  * Wait for {delay} ms
- * @param {number} delay 
- * @returns 
+ * @param {number} delay
+ * @returns
  */
-export const sleep = delay => new Promise(resolve => setTimeout(resolve, delay));
+export const sleep = (delay) => new Promise((resolve) => setTimeout(resolve, delay));
 
 /**
  * Wait for next tick
- * 
- * @returns 
+ *
+ * @returns
  */
-export const yieldToEventLoop = () => new Promise(resolve => setImmediate(resolve));
+export const yieldToEventLoop = () => new Promise((resolve) => setImmediate(resolve));
 
 /**
  * Parse nats:// URL
- * @param {string} url 
- * @returns 
+ * @param {string} url
+ * @returns
  */
 export function parseURL(url) {
     const parsed = new URL(url);
@@ -38,12 +38,12 @@ export function parseURL(url) {
         servers: `${parsed.hostname}:${parsed.port || 4222}`,
         user: parsed.password ? parsed.username : "",
         pass: parsed.password,
-        token: parsed.username && !parsed.password ? parsed.username : undefined
+        token: parsed.username && !parsed.password ? parsed.username : undefined,
     };
 
     return {
         ...basic,
-        ...Object.fromEntries(parsed.searchParams)
+        ...Object.fromEntries(parsed.searchParams),
     };
 }
 
@@ -51,7 +51,9 @@ const BASE62 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 const LOG256_LOG62 = Math.log(256) / Math.log(62); // ≈ 1.3437
 
 export function encodeBase62(buffer) {
-    if (buffer.length === 0) { return ""; }
+    if (buffer.length === 0) {
+        return "";
+    }
     const len = Math.ceil(buffer.length * LOG256_LOG62);
     let n = BigInt("0x" + buffer.toString("hex"));
     const chars = new Array(len);
@@ -73,17 +75,17 @@ export const picoid = (size = 16) => encodeBase62(randomBytes(size));
 
 /**
  * Get SHA256 hash of a string or a buffer
- * @param {string|Buffer} data 
- * @returns 
+ * @param {string|Buffer} data
+ * @returns
  */
 export const hash = (data) => createHash("sha256").update(data).digest("hex");
 
 /**
  * Create TCP or HTTP server at specified port
- * @param {number} port 
- * @param {Object} pkg 
- * @param {Function} handler 
- * @returns 
+ * @param {number} port
+ * @param {Object} pkg
+ * @param {Function} handler
+ * @returns
  */
 export const createServerAtPort = (port, pkg, handler) =>
     new Promise((resolve) => {
@@ -131,7 +133,7 @@ export const proxyHttp = (target, req, res) =>
         const remoteTarget = `${target}${req.originalUrl}`;
         const options = {
             method: req.method,
-            headers: req.headers
+            headers: req.headers,
         };
 
         const protocol = req.protocol === "https" ? https : http;
@@ -151,11 +153,12 @@ export const proxyHttp = (target, req, res) =>
 
 /**
  * Create a object proxy that overlays overlay object
- * @param {*} object 
- * @param {*} overlay 
- * @returns 
+ * @param {*} object
+ * @param {*} overlay
+ * @returns
  */
-export const OverlayObject = (object, overlay) => new Proxy(object, { get: (t, p) => overlay[p] !== undefined ? overlay[p] : t[p] });
+export const OverlayObject = (object, overlay) =>
+    new Proxy(object, { get: (t, p) => (overlay[p] !== undefined ? overlay[p] : t[p]) });
 
 /**
  * The version string of the currently installed Geonix package, read from `package.json` at
@@ -173,24 +176,25 @@ export const GeonixVersion = (() => {
 
 /**
  * Chunk a stream into smaller chunks
- * 
- * @param {*} chunkSize 
- * @returns 
+ *
+ * @param {*} chunkSize
+ * @returns
  */
-export const StreamChunker = (chunkSize = 65536) => new Transform({
-    transform(chunk, _encoding, done) {
-        let offset = 0;
-        while (offset < chunk.length) {
-            const sliceSize = Math.min(chunkSize, chunk.length - offset);
-            this.push(chunk.slice(offset, offset + sliceSize));
-            offset += sliceSize;
-        }
-        done();
-    },
-    flush(done) {
-        done();
-    }
-});
+export const StreamChunker = (chunkSize = 65536) =>
+    new Transform({
+        transform(chunk, _encoding, done) {
+            let offset = 0;
+            while (offset < chunk.length) {
+                const sliceSize = Math.min(chunkSize, chunk.length - offset);
+                this.push(chunk.slice(offset, offset + sliceSize));
+                offset += sliceSize;
+            }
+            done();
+        },
+        flush(done) {
+            done();
+        },
+    });
 
 export async function getFirstItemFromAsyncIterable(asyncIterable) {
     const iterator = asyncIterable[Symbol.asyncIterator]();
@@ -246,7 +250,7 @@ export async function parseMultipart(req, _options) {
     const END_OF_HEADERS = Buffer.from("\r\n\r\n");
     const options = {
         useMemory: false,
-        ..._options
+        ..._options,
     };
     const parts = [];
     let stream = req;
@@ -308,7 +312,7 @@ export async function parseMultipart(req, _options) {
             headers: {},
             bodyFile: options.useMemory ? undefined : bodyFile,
             body: options.useMemory ? [] : createWriteStream(bodyFile, { flags: "wx" }),
-            size: 0
+            size: 0,
         };
         parts.push(activePart);
     };
@@ -341,7 +345,9 @@ export async function parseMultipart(req, _options) {
                     break;
                 }
 
-                const isLastBoundary = combined[boundaryIndex + boundary.length] === 45 && combined[boundaryIndex + boundary.length + 1] === 45;
+                const isLastBoundary =
+                    combined[boundaryIndex + boundary.length] === 45 &&
+                    combined[boundaryIndex + boundary.length + 1] === 45;
 
                 if (boundaryIndex > 0) {
                     write(combined.subarray(0, boundaryIndex));
@@ -360,7 +366,8 @@ export async function parseMultipart(req, _options) {
                 }
 
                 activePart.headers = combined
-                    .subarray(boundaryIndex + boundary.length + 2, endOfHeaders).toString()
+                    .subarray(boundaryIndex + boundary.length + 2, endOfHeaders)
+                    .toString()
                     .split("\r\n")
                     .reduce((acc, val) => {
                         const [header, value] = val.split(": ");
@@ -404,7 +411,7 @@ export async function parseMultipart(req, _options) {
                 try {
                     await unlink(part.bodyFile);
                 } catch {
-                    // ignore errors                        
+                    // ignore errors
                 }
             });
         }

package/src/WebServer.js

@@ -50,7 +50,6 @@ export const ServeStatic = (root, options = {}) => {
 };
 
 class WebServer {
-
     #app = express();
     #server;
     #port;
@@ -60,7 +59,9 @@ class WebServer {
     #routers = [];
 
     async start() {
-        if (this.#started) { return; }
+        if (this.#started) {
+            return;
+        }
 
         this.#started = true;
 
@@ -116,15 +117,14 @@ class WebServer {
                 router = await new Promise((resolve, reject) => {
                     currentResolve = resolve;
 
-                    router(req, res,
-                        (error, _req, _res, _next) => {
-                            if (error) {
-                                return reject(error);
-                            }
+                    router(req, res, (error, _req, _res, _next) => {
+                        if (error) {
+                            return reject(error);
+                        }
 
-                            // go to next router
-                            resolve(routers.shift());
-                        });
+                        // go to next router
+                        resolve(routers.shift());
+                    });
                 });
             }
 
@@ -138,7 +138,7 @@ class WebServer {
         this.#app.all("*", (req, res) => {
             res.status(404).send({
                 error: 404,
-                source: "ws"
+                source: "ws",
             });
         });
 
@@ -175,7 +175,6 @@ class WebServer {
             logger.info("gx.webserver.stop");
         }
     }
-
 }
 
 export const webserver = new WebServer();

package/.vscode/settings.json

@@ -1,11 +0,0 @@
-{
-    "editor.codeActionsOnSave": {
-        "source.fixAll.eslint": "explicit"
-    },
-    "eslint.validate": [
-        "javascript"
-    ],
-    "editor.tabSize": 4,
-    "editor.detectIndentation": false,
-    "editor.formatOnSave": true
-}