geonix 1.8.11 → 1.8.20

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "geonix",
-    "version": "1.8.11",
+    "version": "1.8.20",
     "type": "module",
     "description": "",
     "bin": {

package/src/Connection.js

@@ -55,6 +55,9 @@ class Connection {
             console.log('gx.connection.status', JSON.stringify(event))
     }
 
+    /**
+     * Wait for the connection to be safely closed
+     */
     async waitUntilClosed() {
         await this.#nc.closed()
         this.#closed = true
@@ -68,11 +71,21 @@ class Connection {
         process.exit(1)
     }
 
+    /**
+     * Wait for the connection to be fully established
+     */
     async waitUntilReady() {
         while (!this.#ready)
             await sleep(100)
     }
 
+    /**
+     * Publish JSON
+     * 
+     * @param {string} subject 
+     * @param {object} json 
+     * @returns void
+     */
     async publish(subject, json) {
         if (this.#draining || this.#closed)
             return
@@ -86,6 +99,13 @@ class Connection {
         await this.#nc.publish(subject, payload)
     }
 
+    /**
+     * Publish RAW
+     * 
+     * @param {string} subject 
+     * @param {string | Buffer} data 
+     * @returns void
+     */
     async publishRaw(subject, data) {
         if (this.#draining || this.#closed)
             return
@@ -93,8 +113,16 @@ class Connection {
         await this.#nc.publish(subject, data)
     }
 
+    /**
+     * Request/Reply pattern on top of pub/sub
+     * 
+     * @param {string} subject 
+     * @param {object} json 
+     * @param {object} options 
+     * @returns any
+     */
     async request(subject, json, options = { timeout: 300000 }) {
-        const respondTo = `_INBOX.${picoid(32)}`
+        const respondTo = `gx2.r.${picoid(16)}`
 
         let payload = codec.encode({ $r: respondTo, p: json })
 

package/src/Request.js

@@ -4,6 +4,7 @@ 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
 
@@ -91,7 +92,7 @@ export async function Request(service, method, args = [], context = [], options)
             },
             options)
     } catch (e) {
-        console.debug('GxError: Request', JSON.stringify({
+        console.debug('GxError: Request', inspect({
             originator, service, method, args, context, options,
             error: e, duration: Date.now() - requestBegin
         }))

package/test/inheritance.js

@@ -0,0 +1,60 @@
+import { Service, Remote } from 'geonix'
+
+const calc = Remote('Calculator')
+const tp = Remote('TimeProvider')
+
+class Logger {
+
+    constructor(prefix) {
+        this.prefix = prefix
+    }
+
+    log(...args) {
+        console.log(`${new Date().toISOString()}|${this.prefix}|`, ...args)
+    }
+}
+
+class BaseService extends Service {
+
+    logger = new Logger(this.constructor.name)
+
+}
+
+
+class CalculatorRepository {
+
+    constructor(service) {
+        this.logger = service.logger
+    }
+
+    async getCurrentTime() {
+        this.logger.log('getCurrentTime')
+        return await Remote('TimeProvider').now()
+    }
+
+}
+
+class Calculator extends BaseService {
+
+    repo = new CalculatorRepository(this)
+
+    async onStart() {
+        this.logger.log('current time =', await this.repo.getCurrentTime())
+    }
+
+    thisHere() {
+
+    }
+
+}
+
+class TimeProvider extends BaseService {
+
+    now() {
+        return new Date().toISOString()
+    }
+
+}
+
+Calculator.start()
+TimeProvider.start()

package/test/private.js

@@ -0,0 +1,31 @@
+export const OverlayObject = (object, overlay) => {
+    return new Proxy(object, {
+        get: (t, p) => overlay[p] !== undefined ? overlay[p] : t[p]
+    }
+    )
+}
+
+class Test {
+
+    #me = { works: true }
+
+    get me() { return this.#me }
+
+    external() {
+        return this.me
+    }
+
+    call(method) {
+        try {
+            const methodContext = { context: 'this is context value' }
+            const $context = OverlayObject(this, methodContext)
+            return instance[method].apply($context)
+        } catch (e) {
+        }
+    }
+
+}
+
+const instance = new Test()
+
+console.log(instance.call('external'))

package/test/registration.js

@@ -0,0 +1,29 @@
+import { Service, Remote, registry } from '../exports.js'
+import { sleep } from '../src/Util.js'
+
+class First extends Service {
+
+    getTime() {
+        return new Date().toISOString()
+    }
+
+}
+
+class Second extends Service {
+
+    first = Remote('First')
+
+    async onStart() {
+        while (true) {
+            console.clear()
+            console.log('Time =', await this.first.getTime())
+            console.log('REGISTRY =', registry.getEntries())
+
+            await sleep(1000)
+        }
+    }
+
+}
+
+First.start({ port: 30001 })
+Second.start({ port: 30002 })

package/test/stream2.js

@@ -33,7 +33,6 @@ class StreamTest extends Service {
         const bytes = randomBytes(size)
         const checksum = hash(bytes)
 
-        console.log(size)
         return { checksum, stream: Stream(bytes) }
     }
 

package/src/Serialization.js

@@ -1,33 +0,0 @@
-export function serialize(input) {
-    const process = (value) => {
-        if (value instanceof Buffer) {
-            console.log('this is buffer')
-        }
-
-        if (typeof value === 'object')
-            for (let prop in value)
-                serialize()
-
-        return value
-    }
-
-    let state = input
-
-    process(state)
-
-    return JSON.stringify(state)
-}
-
-export function deserialize(input) {
-
-}
-
-const input = {
-
-}
-
-const s = serialize(input)
-const ds = deserialize(s)
-
-console.log('  serialized =', s)
-console.log('deserialized =', ds)