geonix 1.22.4 → 1.23.0

package/package.json

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

package/src/Service.js

@@ -226,8 +226,10 @@ export class Service {
         }
     }
 
-    async #sub(subject, handler) {
-        const subscription = await connection.subscribe(subject);
+    async #sub(_subject, handler) {
+        const [subject, queue] = _subject.split(",");
+
+        const subscription = await connection.subscribe(subject, { queue });
         const processor = async () => {
             for await (const event of subscription) {
                 handler(event.data);

package/src/WebServer.js

@@ -50,6 +50,8 @@ class WebServer {
     #ready = false;
     #started = false;
 
+    #routers = [];
+
     async start() {
         if (this.#started) { return; }
 
@@ -88,17 +90,41 @@ class WebServer {
             res.send({ status: "healthy", services: Service.serviceClasses });
         });
 
-        // wait for 2 seconds and then set fall-through handler
-        // this should provide more than enough time to start all the services
-        setTimeout(() => {
-            // default answer
-            this.#app.all("*", (req, res) => {
-                res.status(404).send({
-                    error: 404,
-                    source: "ws"
+        // middleware to handle dynamic routers
+        this.#app.use(async (req, res, next) => {
+            const routers = [...this.#routers];
+            let currentResolve;
+            let handled = false;
+
+            res.on("finish", () => {
+                handled = true;
+                currentResolve();
+            });
+
+            let router = routers.shift();
+            while (router) {
+                router = await new Promise((resolve) => {
+                    currentResolve = resolve;
+                    router(req, res, () => {
+                        // go to next router
+                        resolve(routers.shift());
+                    });
                 });
+            }
+
+            if (!handled) {
+                // go to next router
+                next();
+            }
+        });
+
+        // fallthrough handler
+        this.#app.all("*", (req, res) => {
+            res.status(404).send({
+                error: 404,
+                source: "ws"
             });
-        }, 2000);
+        });
 
         // config
         this.#app.disable("x-powered-by");
@@ -115,7 +141,7 @@ class WebServer {
 
     router() {
         const router = Router();
-        this.#app.use(router);
+        this.#routers.push(router);
         return router;
     }
 

package/test/delayedStart.js

@@ -0,0 +1,24 @@
+import { Gateway, Service, streamToBuffer } from "../exports.js";
+import { parseMultipart, sleep } from "../src/Util.js";
+
+class TestService extends Service {
+
+    "GET /test/"(req, res) {
+        res.send("Hello World");
+    }
+
+}
+
+class Application extends Service {
+
+    "GET /"(req, res) {
+        res.send("app");
+    }
+
+}
+
+Application.start();
+
+await sleep(3000);
+
+TestService.start();

package/test/pubsub.js

@@ -0,0 +1,29 @@
+import { Publish, Remote, Service } from "../exports.js";
+import { sleep } from "../src/Util.js";
+
+class TimeService extends Service {
+
+    counter = 0;
+
+    "SUB test,q1"(data) {
+        console.log(`SUB test (${this.counter++})`, data);
+    }
+
+}
+
+class ApplicationService extends Service {
+
+    async onStart() {
+        await sleep(1000);
+
+        while (true) {
+            await Publish("test", "Hello World");
+            await sleep(1000);
+        }
+    }
+
+}
+
+TimeService.start();
+TimeService.start();
+ApplicationService.start();

package/dev.js

@@ -1,62 +0,0 @@
-import { BasicAuth, HTTP, Transport, Unit } from "geonix";
-import { Gateway } from "./src/Gateway.js";
-
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-
-const middleware = [
-    BasicAuth({ realm: "Test", username: "u", password: "pa" })
-];
-
-class TimeService {
-
-    getTime() {
-        return new Date().toISOString();
-    }
-
-    [HTTP.GET("/time", middleware)] = async (req, res) => {
-        res.setHeader("X-Test", "Test");
-        return {
-            time: this.getTime(),
-            id: this.$meta.id
-        };
-    };
-
-    [HTTP.GET("/time2", middleware)] = async (req, res) => {
-        res.setHeader("X-Test", "Test2");
-        return {
-            time: this.getTime(),
-            id: this.$meta.id
-        };
-    };
-
-    [HTTP.filter] = async () => {
-
-    };
-
-    [HTTP.ERROR()] = async () => {
-        return {
-            error: "Unexpected error"
-        };
-    };
-
-}
-
-const transport = await Transport.start("nats://localhost:4222");
-
-await Unit.start(TimeService, {
-    meta: {
-        id: "first",
-    },
-    transport,
-    port: 30000
-});
-
-await Unit.start(TimeService, {
-    meta: {
-        id: "second",
-    },
-    transport,
-    port: 30001
-});
-
-Gateway.start({ transport, gatewayPort: 8080 });