geonix 1.8.10 → 1.8.20

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "geonix",
-    "version": "1.8.10",
+    "version": "1.8.20",
     "type": "module",
     "description": "",
     "bin": {
@@ -16,13 +16,13 @@
     "license": "ISC",
     "dependencies": {
         "cookie-parser": "^1.4.6",
-        "express": "^4.18.1",
+        "express": "^4.18.2",
         "express-async-errors": "^3.1.1",
         "express-ws": "^5.0.2",
         "multer": "^1.4.5-lts.1",
-        "nats": "^2.15.1",
-        "semver": "^7.3.7",
-        "ws": "^8.8.1"
+        "nats": "^2.16.0",
+        "semver": "^7.5.4",
+        "ws": "^8.13.0"
     },
     "publishConfig": {
         "registry": "https://registry.npmjs.org/"

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 })
 
@@ -102,10 +130,10 @@ class Connection {
         if (payload.length > this.getMaxPayloadSize())
             payload = codec.encode(Stream(JSON.stringify({ $r: respondTo, p: json })))
 
-        await this.#nc.publish(subject, payload)
-
         let response = await this.#nc.subscribe(respondTo, { max: 1, ...options })
 
+        await this.#nc.publish(subject, payload)
+
         for await (let event of response)
             return codec.decode(event.data)
     }

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/.env

@@ -0,0 +1 @@
+TRANSPORT=nats://phobos.tria.hr:4222

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/package.json

@@ -11,6 +11,8 @@
     "author": "",
     "license": "ISC",
     "dependencies": {
-        "geonix": "file:.."
+        "dotenv": "^16.3.1",
+        "geonix": "file:..",
+        "nats": "^2.16.0"
     }
 }

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/stream.js

@@ -8,7 +8,7 @@ await connection.waitUntilReady()
 
 const hash = data => createHash('sha512').update(data).digest('base64')
 
-const PAYLOAD_SIZE = 1024 * 1024 * 1024
+const PAYLOAD_SIZE = 1024 * 1024 * 10
 const TEMP_FILE = '/tmp/geonix.stream_test'
 
 console.time('test')

package/test/stream2.js

@@ -0,0 +1,42 @@
+import 'dotenv/config'
+import { randomBytes } from 'node:crypto'
+import { Stream, Remote, getReadable, connection, Service, streamToBuffer } from 'geonix'
+import { createWriteStream, readFileSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+import { pipeline } from 'node:stream/promises'
+
+const hash = data => createHash('sha256').update(data).digest('base64')
+const self = Remote('StreamTest')
+
+class StreamTest extends Service {
+
+    async onStart() {
+        const perform = async (n) => {
+            const fileName = `${n}.random`
+            const { checksum, stream } = await self.readFile(fileName)
+            const data = await streamToBuffer(stream)
+            const verification = hash(data)
+
+            console.log(`${fileName} - ${data.length} bytes - ${checksum === verification}`)
+        }
+
+        const jobs = []
+        for (let n = 0; n < 1024; n++)
+            jobs.push(perform(n))
+
+        await Promise.all(jobs)
+
+        console.log('done')
+    }
+
+    async readFile(fileName, size = 1024 * Math.round(Math.random() * 1024)) {
+        const bytes = randomBytes(size)
+        const checksum = hash(bytes)
+
+        return { checksum, stream: Stream(bytes) }
+    }
+
+
+}
+
+StreamTest.start()

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)