geonix 1.30.2 → 1.31.0

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]();
@@ -199,24 +203,31 @@ export async function getFirstItemFromAsyncIterable(asyncIterable) {
 }
 
 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);
-            }
-
-            if (addressObject.family === "IPv6") {
-                list.push(`[${addressObject.address}]`);
-            }
+    // Loopback entries are seeded first so same-host callers prefer them; the OS-reported
+    // duplicates are filtered out below to keep the prepended ones canonical.
+    const list = ["127.0.0.1", "[::1]"];
+    const interfaces = networkInterfaces() ?? {};
+
+    for (const interfaceAddresses of Object.values(interfaces)) {
+        if (!interfaceAddresses) { continue; }
+        for (const addressObject of interfaceAddresses) {
+            const addr = addressObject.family === "IPv4"
+                ? addressObject.address
+                : addressObject.family === "IPv6"
+                    ? `[${addressObject.address}]`
+                    : null;
+            if (!addr) { continue; }
+            if (addr === "127.0.0.1" || addr === "[::1]") { continue; }
+            list.push(addr);
         }
     }
 
     return list;
 }
 
+export const isLoopbackAddress = (addressWithPort) =>
+    addressWithPort.startsWith("127.0.0.1:") || addressWithPort.startsWith("[::1]:");
+
 export function isIterable(obj) {
     return obj && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function");
 }
@@ -246,7 +257,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 +319,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 +352,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 +373,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 +418,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
-}