geonix 1.8.0 → 1.8.2

package/package.json

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

package/src/Connection.js

@@ -103,14 +103,22 @@ class Connection {
             payload = codec.encode(Stream(JSON.stringify({ $r: respondTo, p: json })))
 
         await this.#nc.publish(subject, payload)
-        const response = await this.#nc.subscribe(respondTo, { max: 1, ...options })
+
+        try {
+            const response = await this.#nc.subscribe(respondTo, { max: 1, ...options })
+        } catch (e) {
+            console.debug('GxDebug -----')
+            console.log({ subject, json })
+            console.debug('-------------')
+            throw e
+        }
 
         for await (let event of response)
             return codec.decode(event.data)
     }
 
     async subscribe(subject, options) {
-        return await this.#nc.subscribe(subject, options)
+        return this.#nc.subscribe(subject, options)
     }
 
     async unsubscribe(subscription) {

package/src/Request.js

@@ -77,15 +77,20 @@ export async function Request(service, method, args = [], context = [], options)
     if (!identifier)
         throw Error(`Request: requested instance of ${service} not found`)
 
-    let response = await connection.request(
-        `gx2.service.${hash(identifier)}`,
-        {
-            m: method,
-            a: args,
-            c: context,
-            o: getOriginator()
-        },
-        options)
+    try {
+        const originator = getOriginator()
+        let response = await connection.request(
+            `gx2.service.${hash(identifier)}`,
+            {
+                m: method,
+                a: args,
+                c: context,
+                o: originator
+            },
+            options)
+    } catch (e) {
+
+    }
 
     // automatically process streamed response
     if (isStream(response))

package/src/Serialization.js

@@ -0,0 +1,33 @@
+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)

package/src/Stream.js

@@ -28,15 +28,12 @@ export function Stream(data) {
     readable = transform
 
     const controlHandler = async () => {
-        const control = await connection.subscribe(`gx2.stream.${id}.a`)
+        const control = await connection.subscribe(`gx2.stream.${id}.a`, { max: 1 })
 
         for await (const event of control)
             if (event.data.length === 0) {
                 readable.on('data', chunk => connection.publishRaw(`gx2.stream.${id}.b`, chunk))
-                readable.on('close', () => {
-                    connection.publishRaw(`gx2.stream.${id}.b`)
-                    control.drain()
-                })
+                readable.on('close', () => connection.publishRaw(`gx2.stream.${id}.b`))
             }
     }