geonix 1.12.2 → 1.20.0

package/src/Registry.js

@@ -1,45 +1,51 @@
-import { connection, codec } from './Connection.js'
-import { sleep } from './Util.js'
-import semver from 'semver'
-import EventEmitter from 'events'
+import { connection, codec } from "./Connection.js";
+import { sleep } from "./Util.js";
+import semver from "semver";
+import EventEmitter from "events";
+import { directRequest } from "./Request.js";
 
-const REGISTRY_ENTRY_TIMEOUT = 5000
+const REGISTRY_ENTRY_TIMEOUT = 5000;
 
 /**
  * Registry maintains a local list of available services and their versions.
  */
 class Registry extends EventEmitter {
 
-    #registry = {}
+    #registry = {};
 
     constructor() {
-        super()
+        super();
 
-        this.#start()
+        this.#start();
     }
 
     async #start() {
-        await connection.waitUntilReady()
+        await connection.waitUntilReady();
 
-        this.#beaconListener()
-        this.#garbageCollector()
+        this.#beaconListener();
+        this.#garbageCollector();
     }
 
     async #beaconListener() {
-        const subscription = await connection.subscribe('gx2.beacon')
+        const subscription = await connection.subscribe("gx2.beacon");
 
         for await (const event of subscription) {
-            const data = codec.decode(event.data)
+            let data = codec.decode(event.data);
 
-            const exists = this.#registry[data.i] !== undefined
+            const exists = this.#registry[data.i] !== undefined;
+
+            // if this is a short beacon, request full service info
+            if (!data.n) {
+                data = await directRequest(data.i, "$getServiceInfo");
+            }
 
             this.#registry[data.i] = {
                 ...data,
                 timeout: Date.now() + REGISTRY_ENTRY_TIMEOUT
-            }
+            };
 
             if (!exists)
-                this.emit('added', this.#registry[data.i])
+                this.emit("added", this.#registry[data.i]);
         }
     }
 
@@ -48,51 +54,51 @@ class Registry extends EventEmitter {
      */
     async #garbageCollector() {
         while (true) {
-            const now = Date.now()
+            const now = Date.now();
             for (let identifier in this.#registry) {
-                const entry = this.#registry[identifier]
+                const entry = this.#registry[identifier];
 
                 if (now > entry.timeout) {
-                    delete this.#registry[identifier]
+                    delete this.#registry[identifier];
 
-                    this.emit('removed', entry)
+                    this.emit("removed", entry);
                 }
             }
 
-            await sleep(500)
+            await sleep(500);
         }
     }
 
     getEntries() {
-        return this.#registry
+        return this.#registry;
     }
 
     getIdentifier(service, version, id) {
-        let matches = []
+        let matches = [];
 
         for (let identifier in this.#registry) {
-            const entry = this.#registry[identifier]
+            const entry = this.#registry[identifier];
 
-            let matchName = entry.n === service
-            let matchVersion = version ? semver.satisfies(entry.v, version) : true
-            let matchId = id ? entry.id === id : true
+            let matchName = entry.n === service;
+            let matchVersion = version ? semver.satisfies(entry.v, version) : true;
+            let matchId = id ? entry.id === id : true;
 
             if (matchName && matchVersion && matchId)
-                matches.push(entry)
+                matches.push(entry);
         }
 
         if (matches.length > 0) {
             // return instance id in case of id matching
             if (id)
-                return matches[0].i
+                return matches[0].i;
 
             // sort matched services in the registry by version
-            matches.sort((a, b) => semver.rcompare(a.v, b.v))
+            matches.sort((a, b) => semver.rcompare(a.v, b.v));
 
-            return `${matches[0].n}@${matches[0].v}`
+            return `${matches[0].n}@${matches[0].v}`;
         }
     }
 
 }
 
-export const registry = new Registry()
+export const registry = new Registry();

package/src/Remote.js

@@ -1,4 +1,4 @@
-import { Request } from "./Request.js"
+import { Request } from "./Request.js";
 
 /**
  * Create a remote function proxy
@@ -8,5 +8,5 @@ import { Request } from "./Request.js"
  * @returns {String|Stream|Object}
  */
 export const Remote = (service, ...context) => new Proxy({}, {
-    get: (target, method, receiver) => async (...args) => Request(service, method, args, context)
-})
+    get: (_target, method, _receiver) => async (...args) => Request(service, method, args, context)
+});

package/src/Request.js

@@ -1,36 +1,36 @@
-import { connection } from './Connection.js'
-import { registry } from './Registry.js'
-import { Service } from './Service.js'
-import { hash, sleep } from './Util.js'
-import { RequestOptionsClass } from './RequestOptions.js'
-import { isStream, streamToString } from './Stream.js'
-import { inspect } from 'node:util'
+import { connection } from "./Connection.js";
+import { registry } from "./Registry.js";
+import { Service } from "./Service.js";
+import { hash, sleep } from "./Util.js";
+import { RequestOptionsClass } from "./RequestOptions.js";
+import { isStream, streamToString } from "./Stream.js";
+import { inspect } from "node:util";
 
-const REGISTRY_TIMEOUT = 300000
+const REGISTRY_TIMEOUT = 300000;
 
 /**
  * Get full v8 stack trace
  * @returns 
  */
 function getStack() {
-    const oldLimit = Error.stackTraceLimit
-    const oldHandler = Error.prepareStackTrace
+    const oldLimit = Error.stackTraceLimit;
+    const oldHandler = Error.prepareStackTrace;
     const holder = {};
 
     // set new values
     Error.stackTraceLimit = Infinity;
-    Error.prepareStackTrace = (holder, stackTrace) => stackTrace
+    Error.prepareStackTrace = (holder, stackTrace) => stackTrace;
 
     // capture stack trace
-    Error.captureStackTrace(holder, getStack)
+    Error.captureStackTrace(holder, getStack);
 
-    const stack = holder.stack
+    const stack = holder.stack;
 
     // restore values
-    Error.prepareStackTrace = oldHandler
-    Error.stackTraceLimit = oldLimit
+    Error.prepareStackTrace = oldHandler;
+    Error.stackTraceLimit = oldLimit;
 
-    return stack
+    return stack;
 }
 
 /**
@@ -39,49 +39,63 @@ function getStack() {
  * @returns 
  */
 function getOriginator() {
-    const stack = getStack()
+    const stack = getStack();
 
-    for (let n = 0; n < stack.length; n++) {
-        const typeName = stack[n].getTypeName()
+    for (const item of stack) {
+        const typeName = item.getTypeName();
 
         if (Service.serviceClasses.includes(typeName))
-            return `${typeName}.${stack[n].getMethodName()}`
+            return `${typeName}.${item.getMethodName()}`;
     }
 }
 
 /**
+ * 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 async function Request(service, method, args = [], context = [], options) {
-    const match = service.match(/(?<name>[^@#]*)(@(?<version>[^@#]*))?(#(?<id>[^@#]*))?/)
-    const { name, version, id } = match.groups
+export async function Request(service, method, args, context, options) {
+    const match = /(?<name>[^@#]*)(@(?<version>[^@#]*))?(#(?<id>[^@#]*))?/.exec(service);
+    const { name, version, id } = match.groups;
 
     // allow passing RequestOptions as first arg
     if (args?.length > 0 && args[0] instanceof RequestOptionsClass)
-        options = (args.shift())?.options
+        options = (args.shift())?.options;
 
-    let identifier = null
+    let identifier = null;
 
     // get service instance identifier and wait for it if it's not available
-    const registryTimeout = options?.timeout ?? REGISTRY_TIMEOUT
-    const delay = 5
-    let retries = Math.floor(registryTimeout / delay)
+    const registryTimeout = options?.timeout ?? REGISTRY_TIMEOUT;
+    const delay = 5;
+    let retries = Math.floor(registryTimeout / delay);
     while (identifier == null && retries-- > 0) {
-        identifier = registry.getIdentifier(name, version, id)
+        identifier = registry.getIdentifier(name, version, id);
         if (!identifier)
-            await sleep(delay)
+            await sleep(delay);
     }
 
-    if (!identifier)
-        throw Error(`Request: requested instance of ${service} not found`)
+    return directRequest(identifier, method, args, context, options, service);
+}
 
-    let response
-    const originator = getOriginator()
-    let requestBegin = Date.now()
+/**
+ * Send a request to a service
+ * 
+ * @param {string} identifier 
+ * @param {string} method 
+ * @param {any[]} args 
+ * @param {any[]} context 
+ * @param {object} options 
+ * @returns 
+ */
+export async function directRequest(identifier, method, args, context, options, service) {
+    let response;
+    const originator = getOriginator();
+    let requestBegin = Date.now();
     try {
         response = await connection.request(
             `gx2.service.${hash(identifier)}`,
@@ -91,28 +105,28 @@ export async function Request(service, method, args = [], context = [], options)
                 c: context,
                 o: originator
             },
-            options)
+            options);
 
         // automatically process streamed response
         if (isStream(response))
-            response = JSON.parse(await streamToString(response))
+            response = JSON.parse(await streamToString(response));
     } catch (e) {
-        console.debug('GxError: Request', inspect({
-            originator, service, method, args, context, options,
+        console.debug("GxError: directRequest", inspect({
+            originator, service: service ?? identifier, method, args, context, options,
             error: e, duration: Date.now() - requestBegin
-        }))
+        }));
 
-        throw e
+        throw e;
     }
 
     if (!response)
-        throw Error(`Request: invalid response`)
+        throw Error("Request: invalid response");
 
     // got error?
     if (response.e)
-        throw Error(`Request: remote error: ${response.e}`)
+        throw Error(`Request: remote error: ${response.e}`);
 
-    return response.r
+    return response.r;
 }
 
 /**
@@ -122,7 +136,7 @@ export async function Request(service, method, args = [], context = [], options)
  * @param {string|number} payload 
  */
 export async function Publish(subject, payload) {
-    connection.publishRaw(`gx.sub.${subject}`, Buffer.from(payload))
+    connection.publishRaw(`gx.sub.${subject}`, Buffer.from(payload));
 }
 
 /**
@@ -133,10 +147,10 @@ export async function Publish(subject, payload) {
  * @returns 
  */
 export async function Subscribe(subject, callback) {
-    if (typeof callback !== 'function')
-        return
+    if (typeof callback !== "function")
+        return;
 
-    const subscription = await connection.subscribe(`gx.sub.${subject}`)
+    const subscription = await connection.subscribe(`gx.sub.${subject}`);
     for await (const event of subscription)
-        callback(event.data)
+        callback(event.data);
 }

package/src/RequestOptions.js

@@ -1,10 +1,10 @@
 export class RequestOptionsClass {
-    options
+    options;
     constructor(options) {
-        this.options = options
+        this.options = options;
     }
 }
 
 export const RequestOptions = (options) => {
-    return new RequestOptionsClass(options)
-}
+    return new RequestOptionsClass(options);
+};