geonix 1.12.3 → 1.20.1

package/eslint.config.js

@@ -0,0 +1,25 @@
+import globals from "globals";
+import eslint from "@eslint/js";
+
+export default [
+    eslint.configs.recommended,
+    {
+        files: ["**/*.js"],
+        languageOptions: {
+            ecmaVersion: 2022,
+            sourceType: "module",
+            globals: {
+                ...globals.node,
+                ...globals.browser,
+            }
+        },
+        rules: {
+            // "no-console": "error",
+            semi: "error",
+            "no-unused-vars": ["error", { argsIgnorePattern: "^_.*" }],
+            "no-constant-condition": ["error", { checkLoops: false }],
+            quotes: ["error", "double", { avoidEscape: true }],
+            "no-multiple-empty-lines": ["error", { max: 1 }]
+        },
+    }
+];

package/examples/ServeStatic/index.js

@@ -1,14 +1,14 @@
-import { Service } from 'geonix'
-import { ServeStatic } from 'geonix'
+import { Service } from "geonix";
+import { ServeStatic } from "geonix";
 
 class StaticServer extends Service {
 
     // simple version
-    'GET *' = ServeStatic('public')
+    "GET *" = ServeStatic("public");
 
     // in a folder
-    'GET /folder/*' = ServeStatic('public', { root: '/folder/' })
+    "GET /folder/*" = ServeStatic("public", { root: "/folder/" });
 
 }
 
-StaticServer.start()
+StaticServer.start();

package/examples/ServeStatic/package.json

@@ -1,15 +1,15 @@
 {
-  "name": "servicestatic",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "type": "module",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "author": "",
-  "license": "ISC",
-  "dependencies": {
-    "geonix": "^1.0.13"
-  }
-}
+    "name": "servicestatic",
+    "version": "1.0.0",
+    "description": "",
+    "main": "index.js",
+    "type": "module",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "author": "",
+    "license": "ISC",
+    "dependencies": {
+        "geonix": "^1.0.13"
+    }
+}

package/examples/SimpleService/index.js

@@ -1,13 +1,13 @@
-import { Service } from 'geonix'
+import { Service } from "geonix";
 
 class SimpleService extends Service {
 
     reverseString(input) {
-        return input.split('').reverse().join('')
+        return input.split("").reverse().join("");
     }
 
-    'GET /simpleservice/reversestring'(req, res) {
-        res.send(this.reverseString(req.query.q))
+    "GET /simpleservice/reversestring"(req, res) {
+        res.send(this.reverseString(req.query.q));
     }
 
 }
@@ -16,12 +16,12 @@ class SimpleService extends Service {
 
 class TestService extends Service {
 
-    'GET /test'(req, res) {
-        console.log('rawr')
+    "GET /test"(req, res) {
+        console.log("rawr");
 
-        res.send('ok')
+        res.send("ok");
     }
 
 }
 
-TestService.start()
+TestService.start();

package/examples/SimpleService/package.json

@@ -1,15 +1,15 @@
 {
-  "name": "simpleservice",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "type": "module",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "author": "",
-  "license": "ISC",
-  "dependencies": {
-    "geonix": "^1.0.16"
-  }
-}
+    "name": "simpleservice",
+    "version": "1.0.0",
+    "description": "",
+    "main": "index.js",
+    "type": "module",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "author": "",
+    "license": "ISC",
+    "dependencies": {
+        "geonix": "^1.0.16"
+    }
+}

package/exports.js

@@ -1,43 +1,14 @@
-import { readFile } from 'fs/promises'
-import semver from 'semver'
-import { URL, fileURLToPath } from 'url'
-import { join } from 'path'
-
-try {
-    const __dirname = fileURLToPath(new URL('.', import.meta.url));
-    const local = JSON.parse(await readFile(join(__dirname, 'package.json')))
-    let remote = await (await fetch('https://registry.npmjs.com/-/v1/search?text=geonix')).json()
-
-    if (remote?.objects?.length > 0) {
-        remote = remote.objects[0].package
-
-        _geonix_version = local.version
-
-        if (semver.lt(local.version, remote.version)) {
-            let line = `${local.version} → ${remote.version}`
-            line = ' '.repeat(Math.floor((39 - line.length) / 2)) + line + ' '.repeat(Math.ceil((39 - line.length) / 2))
-
-            console.log(`╭───────────────────────────────────────╮`)
-            console.log(`│        Geonix update available        │`)
-            console.log(`│${line}│`)
-            console.log(`╰───────────────────────────────────────╯`)
-        }
-    }
-} catch (e) {
-    // silently ignore version check
-}
-
-export * from './src/Service.js'
-export * from './src/Stream.js'
-export * from './src/Remote.js'
-
-export { ServeStatic } from './src/WebServer.js'
-export { Gateway } from './src/Gateway.js'
-export { GeonixVersion } from './src/Util.js'
-export { connection, stopConnection } from './src/Connection.js'
-export { registry } from './src/Registry.js'
-export { Request, Subscribe, Publish } from './src/Request.js'
-export { RequestOptions } from './src/RequestOptions.js'
-export { picoid as randomID } from './src/Util.js'
-
-export { stats as StreamStats } from './src/Stream.js'
+export * from "./src/Service.js";
+export * from "./src/Stream.js";
+export * from "./src/Remote.js";
+
+export { ServeStatic } from "./src/WebServer.js";
+export { Gateway } from "./src/Gateway.js";
+export { GeonixVersion } from "./src/Util.js";
+export { connection, stopConnection } from "./src/Connection.js";
+export { registry } from "./src/Registry.js";
+export { Request, Subscribe, Publish } from "./src/Request.js";
+export { RequestOptions } from "./src/RequestOptions.js";
+export { picoid as randomID } from "./src/Util.js";
+
+export { stats as StreamStats } from "./src/Stream.js";

package/index.d.ts

@@ -47,7 +47,7 @@ declare class Connection {
      * @param {object} options
      * @returns any
      */
-    request(subject: string, json: object, options?: object): Promise<unknown>;
+    request(subject: string, json: object, opts?: {}): Promise<unknown>;
     subscribe(subject: any, options: any): Promise<any>;
     unsubscribe(subscription: any): Promise<void>;
     /**
@@ -77,13 +77,27 @@ declare class Registry {
 export {};
 export function Remote(service: string, ...context: (string | Stream | Object)[]): string | Stream | Object;
 /**
+ * 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 function Request(service: any, method: any, args: any, context: any[] | undefined, options: any): Promise<any>;
+export function Request(service: string, method: string, args: any[], context: any[], options: object): Promise<any>;
+/**
+ * Send a request to a service
+ *
+ * @param {string} identifier
+ * @param {string} method
+ * @param {any[]} args
+ * @param {any[]} context
+ * @param {object} options
+ * @returns
+ */
+export function directRequest(identifier: string, method: string, args: any[], context: any[], options: object, service: any): Promise<any>;
 /**
  * Publish payload to a subject
  *
@@ -107,10 +121,9 @@ export function RequestOptions(options: any): RequestOptionsClass;
 export class Service {
     static serviceClasses: any[];
     static start(options?: {}): void;
-    static static(): void;
     connections: Map<any, any>;
-    SYS_createConnection(streamId: any): Promise<boolean>;
-    SYS_getEnv(): Promise<{
+    $createConnection(streamId: any): Promise<boolean>;
+    $getEnv(): {
         geonix: string;
         node: {
             version: any;
@@ -121,11 +134,12 @@ export class Service {
         mem: any;
         rss: any;
         cpu: any;
-    }>;
+    };
+    $getServiceInfo(): {};
     #private;
 }
 /**
- * Converts input data to stream
+ * Converts data to stream
  *
  * @param {*} data
  * @param {*} automated
@@ -133,10 +147,8 @@ export class Service {
  */
 export function Stream(data: any, tag?: string): any;
 export function isStream(object: any): any;
-export function getReadable(object: any, forceNats?: boolean): Promise<any>;
-export function getReadableOverHTTP(object: any): Promise<any>;
-export function getReadableOverNATS(object: any): Promise<any>;
-export function streamToBuffer(object: any, forceNats?: boolean): Promise<any>;
+export function getReadable(object: any): Promise<any>;
+export function streamToBuffer(object: any): Promise<any>;
 export function streamToString(object: any): Promise<any>;
 export const stats: {};
 /**
@@ -144,16 +156,8 @@ export const stats: {};
  * @param {string} url
  * @returns
  */
-export function parseURL(url: string): {
-    servers: string;
-    user: any;
-    pass: any;
-    token: any;
-};
-export function timeoutAsyncGenerator(target: any, ms: any): {};
-export function waitForAbort(abortSignal: any, result: any): Promise<any>;
-export function abortableAsyncGenerator(target: any, abortSignal: any): {};
-export function getNetworkAddresses(): any[];
+export function parseURL(url: string): any;
+export function getFirstItemFromAsyncIterable(asyncIterable: any): Promise<any>;
 export function sleep(delay: number): Promise<any>;
 export function picoid(size?: number): any;
 export function hash(data: string | Buffer): any;
@@ -172,6 +176,7 @@ export function ServeStatic(root: any, options?: {}): any;
 export const webserver: WebServer;
 declare class WebServer {
     start(): Promise<void>;
+    getAddresses(): any[];
     getPort(): any;
     router(): any;
     waitUntilReady(): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "geonix",
-    "version": "1.12.3",
+    "version": "1.20.1",
     "type": "module",
     "description": "",
     "bin": {
@@ -9,22 +9,26 @@
     "main": "exports.js",
     "scripts": {
         "test": "echo \"Error: no test specified\" && exit 1",
-        "build": "tsc && cat build/* > index.d.ts && rm -rf build",
+        "build": "npx tsc && cat build/* > index.d.ts && rm -rf build",
         "deploy": "npm run build && npm publish"
     },
     "author": "Davor Tarandek <dtarandek@tria.hr>",
     "license": "MIT",
     "dependencies": {
         "cookie-parser": "^1.4.6",
-        "express": "^4.18.2",
+        "express": "^4.19.2",
         "express-async-errors": "^3.1.1",
         "express-ws": "^5.0.2",
         "multer": "^1.4.5-lts.1",
-        "nats": "^2.19.0",
-        "semver": "^7.5.4",
-        "ws": "^8.16.0"
+        "nats": "^2.28.2",
+        "semver": "^7.6.3",
+        "ws": "^8.18.0"
     },
     "publishConfig": {
         "registry": "https://registry.npmjs.org/"
+    },
+    "devDependencies": {
+        "eslint": "^9.9.1",
+        "typescript": "^5.5.4"
     }
 }

package/src/Connection.js

@@ -1,11 +1,14 @@
-import { connect, JSONCodec } from 'nats'
-import { parseURL, picoid, sleep } from './Util.js'
-import { Stream } from './Stream.js'
-import { webserver } from './WebServer.js'
+import { connect, JSONCodec } from "nats";
+import { parseURL, picoid, sleep } from "./Util.js";
+import { Stream } from "./Stream.js";
+import { webserver } from "./WebServer.js";
 
 // -------------------------------------------------------------------------------------------------
-const REQUEST_TIMEOUT = 30000
-const CONNECTION_TIMEOUT = 10000
+const CONNECTION_TIMEOUT = 10000;
+
+const defaultRequestOptions = {
+    timeout: 300000
+};
 // -------------------------------------------------------------------------------------------------
 
 /**
@@ -17,58 +20,70 @@ const CONNECTION_TIMEOUT = 10000
  */
 class Connection {
 
-    #draining = false
-    #closed = false
-    #ready = false
-    #nc
+    #draining = false;
+    #closed = false;
+    #ready = false;
+    #connections = [];
+    #connectionRoundRobin = 0;
+
+    #getConnection() {
+        this.#connectionRoundRobin = ++this.#connectionRoundRobin % this.#connections.length;
+        return this.#connections[this.#connectionRoundRobin];
+    }
 
     /**
      * Initiates connection to transport
      * @param {string} transport 
      */
-    async start(transport = process.env.TRANSPORT || 'nats://localhost') {
+    async start(transport = process.env.TRANSPORT || "nats://localhost") {
         const defaults = {
             timeout: CONNECTION_TIMEOUT,
             reconnect: true,
-            debug: process.env.TRANSPORT_DEBUG === 'true',
+            debug: process.env.TRANSPORT_DEBUG === "true",
             maxReconnectAttempts: 30,
             pingInterval: 30000,
-            waitOnFirstConnect: true
-        }
+            waitOnFirstConnect: true,
+            connections: 1
+        };
         const options = {
             ...defaults,
             ...parseURL(transport)
-        }
+        };
 
-        this.#nc = await connect(options)
+        for (let i = 0; i < options.connections; i++) {
+            this.#connections.push(await connect(options));
+        }
 
-        console.log('gx.connection.connected')
+        console.log("gx.connection.connected");
 
-        this.#ready = true
+        this.#ready = true;
 
-        this.monitorStatus()
-        this.waitUntilClosed()
+        this.monitorStatus();
+        this.waitUntilClosed();
     }
 
     async monitorStatus() {
-        for await (const event of this.#nc.status())
-            console.log('gx.connection.status', JSON.stringify(event))
+        for await (const event of this.#getConnection().status()) {
+            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
-        console.log('gx.connection.closed')
+        // wait for all connections to be closed
+        await Promise.all(this.#connections.map(connection => connection.closed()));
+
+        this.#closed = true;
+        console.log("gx.connection.closed");
 
-        webserver.stop()
+        webserver.stop();
 
-        await sleep(5000)
+        await sleep(5000);
 
-        console.log('gx.terminate')
-        process.exit(1)
+        console.log("gx.terminate");
+        process.exit(1);
     }
 
     /**
@@ -76,7 +91,7 @@ class Connection {
      */
     async waitUntilReady() {
         while (!this.#ready)
-            await sleep(100)
+            await sleep(100);
     }
 
     /**
@@ -88,15 +103,15 @@ class Connection {
      */
     async publish(subject, json) {
         if (this.#draining || this.#closed)
-            return
+            return;
 
-        let payload = codec.encode(json)
+        let payload = codec.encode(json);
 
         // if payload is too big, convert it to Stream
         if (payload.length > this.getMaxPayloadSize())
-            payload = codec.encode(Stream(JSON.stringify(json)))
+            payload = codec.encode(Stream(JSON.stringify(json)));
 
-        await this.#nc.publish(subject, payload)
+        await this.#getConnection().publish(subject, payload);
     }
 
     /**
@@ -108,9 +123,9 @@ class Connection {
      */
     async publishRaw(subject, data) {
         if (this.#draining || this.#closed)
-            return
+            return;
 
-        await this.#nc.publish(subject, data)
+        await this.#getConnection().publish(subject, data);
     }
 
     /**
@@ -121,29 +136,35 @@ class Connection {
      * @param {object} options 
      * @returns any
      */
-    async request(subject, json, options = { timeout: 300000 }) {
-        const respondTo = `gx2.r.${picoid(16)}`
+    async request(subject, json, opts = {}) {
+        const options = {
+            ...defaultRequestOptions,
+            ...opts
+        };
 
-        let payload = codec.encode({ $r: respondTo, p: json })
+        const respondTo = `gx2.r.${picoid(16)}`;
+
+        let payload = codec.encode({ $r: respondTo, p: json });
 
         // if payload is too big, convert it to Stream
         if (payload.length > this.getMaxPayloadSize())
-            payload = codec.encode(Stream(JSON.stringify({ $r: respondTo, p: json })))
+            payload = codec.encode(Stream(JSON.stringify({ $r: respondTo, p: json })));
 
-        let response = await this.#nc.subscribe(respondTo, { max: 1, ...options })
+        const nc = this.#getConnection();
+        let response = await nc.subscribe(respondTo, { max: 1, ...options });
 
-        await this.#nc.publish(subject, payload)
+        await nc.publish(subject, payload);
 
         for await (let event of response)
-            return codec.decode(event.data)
+            return codec.decode(event.data);
     }
 
     async subscribe(subject, options) {
-        return this.#nc.subscribe(subject, options)
+        return this.#getConnection().subscribe(subject, options);
     }
 
     async unsubscribe(subscription) {
-        subscription.unsubscribe()
+        subscription.unsubscribe();
     }
 
     /**
@@ -151,28 +172,30 @@ class Connection {
      * @returns {number}
      */
     getMaxPayloadSize() {
-        return this.#nc?.info?.max_payload || 1024 * 512
+        const nc = this.#getConnection();
+        return nc?.info?.max_payload || 1024 * 512;
     }
 
     isClosed() {
-        return this.#closed
+        return this.#closed;
     }
 
     async drain() {
-        this.#draining = true
-        await this.#nc.drain()
+        this.#draining = true;
+
+        await Promise.all(this.#connections.map(connection => connection.drain()));
     }
 
 }
 
-export const codec = JSONCodec()
+export const codec = JSONCodec();
 
-export const connection = new Connection()
-connection.start()
+export const connection = new Connection();
+connection.start();
 
 export const stopConnection = () => {
     if (!connection)
-        return
+        return;
 
-    connection.drain()
-}
+    connection.drain();
+};