geonix 1.8.11 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "geonix",
-    "version": "1.8.11",
+    "version": "1.9.0",
     "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/src/Service.js

@@ -32,11 +32,14 @@ export class Service {
 
     }
 
-    // ---------------------------------------------------------------------------------------------
+    // ---------------------------------------------------------------------------------------------    
 
     #me = {}
+    #options = {}
 
     async #start(options = {}) {
+        this.#options = options
+
         await webserver.waitUntilReady()
         await connection.waitUntilReady()
 
@@ -145,6 +148,11 @@ export class Service {
 
             let handlers = (Array.isArray(this[endpoint]) ? this[endpoint] : [this[endpoint]])
 
+            if (Array.isArray(this.#options?.handlers?.before))
+                handlers = [...this.#options?.handlers?.before, ...handlers]
+            if (Array.isArray(this.#options?.handlers?.after))
+                handlers = [...handlers, ...this.#options?.handlers?.after]
+
             for (let n = 0; n < handlers.length; n++)
                 handlers[n] = handlers[n].bind(this)
 

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,36 @@
+import { Service, Remote, registry } from '../exports.js'
+import { sleep } from '../src/Util.js'
+
+class BaseService extends Service {
+
+    static start(options = {}) {
+        super.start({
+            ...options,
+            handlers: {
+                before: [
+                    (req, res, next) => {
+                        console.log('before')
+                        next()
+                    }
+                ],
+                after: [(error, req, res, next) => {
+                    if (error) {
+                        res.send({ status: 'rawr', error: error.message })
+                    }
+                }]
+            }
+        })
+    }
+
+}
+
+class First extends BaseService {
+
+    'GET /wow'(req, res) {
+        throw Error('wow')
+    }
+
+}
+
+
+First.start()

package/test/shitstorm.js

@@ -0,0 +1,43 @@
+import { readFile } from 'fs/promises';
+import { Service, Stream, getReadable } from '../exports.js';
+
+process.env.LOCAL_PORT = 1234
+
+class DownloadServiceDebuggingSession extends Service {
+
+    #transferCounter = 1
+
+    onStart() {
+        console.log("Starting service...");
+    }
+
+    'GET /api/download/local' = [
+        async (_, res) => {
+            const id = this.#transferCounter++
+
+            console.log(`transfer=${id} begin`)
+            const result = await this.getLocalFile()
+            console.log(`transfer=${id} stream=${JSON.stringify(result)}`)
+            const stream = await getReadable(result)
+            console.log(`transfer=${id}`)
+            stream.pipe(res)
+
+            let counter = 0;
+            stream.on('data', (chunk) => {
+                counter += chunk.length
+                // console.log(`transfer=${id} sent=${(counter / 1024 / 1024).toFixed(2).padStart()}`)
+            })
+
+            stream.on('end', () => {
+                console.log(`transfer=${id} end`)
+            })
+        }
+    ]
+
+    getLocalFile = async () => {
+        const buffer = await readFile("./test150.txt")
+        return Stream(buffer)
+    }
+}
+
+DownloadServiceDebuggingSession.start()

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)