relayx-webjs 1.0.0 → 1.0.2

package/CHANGELOG.md

@@ -1,6 +1,7 @@
-V1.0.8
-- History API fetch() to consume()
+V1.0.2
+- Wildcard topics for pub / sub fixes
+- Unit tests added for wildcard pattern matching
 
-V1.0.7
-- History API added
-- README updated to explain history API usage
+V1.0.1
+- Wildcard topics for pub / sub
+- Message replay on reconnection

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relayx-webjs",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "A powerful library for integrating real-time communication into your webapps, powered by the Relay Network.",
   "main": "realtime/realtime.js",
   "type": "module",

package/realtime/realtime.js

@@ -11,6 +11,7 @@ export class Realtime {
     #codec = JSONCodec();
     #jetstream = null;
     #consumerMap = {};
+    #consumer = null;
 
     #event_func = {}; 
     #topicMap = []; 
@@ -223,7 +224,6 @@ export class Realtime {
                         this.#log(`client disconnected - ${s.data}`);
 
                         this.connected = false;
-                        this.#consumerMap = {};
 
                         if (DISCONNECTED in this.#event_func){
                             if (this.#event_func[DISCONNECTED] !== null || this.#event_func[DISCONNECTED] !== undefined){
@@ -282,13 +282,15 @@ export class Realtime {
     /**
      * Closes connection
      */
-    close(){
+    async close(){
         if(this.#natsClient !== null){
             this.reconnected = false;
             this.disconnected = true;
             
             this.#offlineMessageBuffer.length = 0;
 
+            await this.#deleteConsumer();
+
             this.#natsClient.close();
         }else{
             this.#log("Null / undefined socket, cannot close connection");
@@ -299,10 +301,9 @@ export class Realtime {
      * Start consumers for topics initialized by user
      */
     async #subscribeToTopics(){
-        this.#topicMap.forEach(async (topic) => {
-            // Subscribe to stream
-            await this.#startConsumer(topic); 
-        });
+        if(this.#topicMap.length > 0){
+            await this.#startConsumer(); 
+        }
     }
 
     /**
@@ -323,8 +324,6 @@ export class Realtime {
         this.#topicMap = this.#topicMap.filter(item => item !== topic);
 
         delete this.#event_func[topic];
-
-        return await this.#deleteConsumer(topic);
     }
 
     /**
@@ -467,6 +466,10 @@ export class Realtime {
             throw new Error(`Expected $topic type -> string. Instead receieved -> ${typeof topic}`);
         }
 
+        if(!this.isTopicValid(topic)){
+            throw new Error("Invalid topic, use isTopicValid($topic) to validate topic")
+        }
+
         if(start == undefined || start == null){
             throw new Error(`$start must be provided. $start is => ${start}`)
         }
@@ -568,39 +571,49 @@ export class Realtime {
      * @param {string} topic 
      */
     async #startConsumer(topic){
+        if(this.#consumer != null){
+            return;
+        }
+
         this.#log(`Starting consumer for topic: ${topic}_${uuidv4()}`)
 
         var opts = { 
-            name: `${topic}_${uuidv4()}`,
-            filter_subjects: [this.#getStreamTopic(topic), this.#getStreamTopic(topic) + "_presence"],
+            name: `${uuidv4()}`,
+            filter_subjects: [this.#getStreamTopic(">")],
             replay_policy: ReplayPolicy.Instant,
             opt_start_time: new Date(),
             ack_policy: AckPolicy.Explicit,
             delivery_policy: DeliverPolicy.New
         }
 
-        const consumer = await this.#jetstream.consumers.get(this.#getStreamName(), opts);
+        this.#consumer = await this.#jetstream.consumers.get(this.#getStreamName(), opts);
         this.#log(this.#topicMap)
 
-        this.#consumerMap[topic] = consumer;
-
-        await consumer.consume({
+        await this.#consumer.consume({
             callback: async (msg) => {
                 try{
                     const now = Date.now();
                     this.#log("Decoding msgpack message...")
                     var data = decode(msg.data);
 
-                    var room = data.room;
+                    var room = this.#stripStreamHash(msg.subject);
 
                     this.#log(data);
 
                     // Push topic message to main thread
-                    if (room in this.#event_func && data.client_id != this.#getClientId()){
-                        this.#event_func[room]({
-                            "id": data.id,
-                            "data": data.message
-                        });
+                    if (data.client_id != this.#getClientId()){
+                        var topics = this.#getCallbackTopics(room);
+                        this.#log(topics)
+
+                        for(let i = 0; i < topics.length; i++){
+                            var top = topics[i];
+
+                            this.#event_func[top]({
+                                "id": data.id,
+                                "topic": room,
+                                "data": data.message
+                            });
+                        }
                     }
 
                     msg.ack();
@@ -608,7 +621,7 @@ export class Realtime {
                     await this.#logLatency(now, data);
                 }catch(err){
                     this.#log("Consumer err " + err);
-                    msg.nack(5000);
+                    msg.nak(5000);
                 }
             }
         });
@@ -619,19 +632,15 @@ export class Realtime {
      * Deletes consumer
      * @param {string} topic 
      */
-    async #deleteConsumer(topic){
-        const consumer = this.#consumerMap[topic]
-
+    async #deleteConsumer(){
         var del = false;
 
-        if (consumer != null && consumer != undefined){
-            del = await consumer.delete();
+        if (this.#consumer != null && this.#consumer != undefined){
+            del = await this.#consumer.delete();
         }else{
             del = false
         }
 
-        delete this.#consumerMap[topic];
-
         return del;
     }
 
@@ -734,7 +743,9 @@ export class Realtime {
             var arrayCheck = ![CONNECTED, DISCONNECTED, RECONNECT, this.#RECONNECTED,
                 this.#RECONNECTING, this.#RECONN_FAIL, MESSAGE_RESEND, SERVER_DISCONNECT].includes(topic);
 
-            var spaceStarCheck = !topic.includes(" ") && !topic.includes("*") && !topic.includes(".");
+            const TOPIC_REGEX = /^(?!.*\$)(?:[A-Za-z0-9_*~-]+(?:\.[A-Za-z0-9_*~-]+)*(?:\.>)?|>)$/u;
+
+            var spaceStarCheck = !topic.includes(" ") && TOPIC_REGEX.test(topic);
 
             return arrayCheck && spaceStarCheck;
         }else{
@@ -789,6 +800,91 @@ export class Realtime {
         }
     }
 
+    #stripStreamHash(topic){
+        return topic.replace(`${this.topicHash}.`, "")
+    }
+
+    #getCallbackTopics(topic){
+        var validTopics = [];
+
+        var topicPatterns = Object.keys(this.#event_func);
+
+        for(let i = 0; i < topicPatterns.length; i++){
+            var pattern = topicPatterns[i];
+
+            if([CONNECTED, RECONNECT, MESSAGE_RESEND, DISCONNECTED, SERVER_DISCONNECT].includes(pattern)){
+                continue;
+            }
+
+            var match = this.#topicPatternMatcher(pattern, topic);
+
+            if(match){
+                validTopics.push(pattern)
+            }
+        }
+
+        return validTopics;
+
+    }
+
+    #topicPatternMatcher(patternA, patternB) {
+        const a = patternA.split(".");
+        const b = patternB.split(".");
+
+        let i = 0, j = 0;          // cursors in a & b
+        let starAi = -1, starAj = -1; // last '>' position in A and the token count it has consumed
+        let starBi = -1, starBj = -1; // same for pattern B
+
+        while (i < a.length || j < b.length) {
+            const tokA = a[i];
+            const tokB = b[j];
+
+            /*──────────── literal match or single‑token wildcard on either side ────────────*/
+            const singleWildcard =
+            (tokA === "*" && j < b.length) ||
+            (tokB === "*" && i < a.length);
+
+            if (
+            (tokA !== undefined && tokA === tokB) ||
+            singleWildcard
+            ) {
+            i++; j++;
+            continue;
+            }
+
+            /*────────────────── multi‑token wildcard ">" — must be **final** ───────────────*/
+            if (tokA === ">") {
+            if (i !== a.length - 1) return false;   // '>' not in last position → invalid
+            if (j >= b.length)      return false;   // must consume at least one token
+            starAi = i++;                       // remember where '>' is
+            starAj = ++j;                       // gobble one token from B
+            continue;
+            }
+            if (tokB === ">") {
+            if (j !== b.length - 1) return false;   // same rule for patternB
+            if (i >= a.length)      return false;
+            starBi = j++;
+            starBj = ++i;
+            continue;
+            }
+
+            /*───────────────────────────── back‑track using last '>' ───────────────────────*/
+            if (starAi !== -1) {          // let patternA's '>' absorb one more token of B
+            j = ++starAj;
+            continue;
+            }
+            if (starBi !== -1) {          // let patternB's '>' absorb one more token of A
+            i = ++starBj;
+            continue;
+            }
+
+            /*────────────────────────────────── dead‑end ───────────────────────────────────*/
+            return false;
+        }
+
+        return true; 
+    } 
+
     sleep(ms) {
         return new Promise(resolve => setTimeout(resolve, ms));
     }
@@ -927,6 +1023,14 @@ ${secret}
             return null; 
         }
     }
+
+    testPatternMatcher(){
+        if(process.env.NODE_ENV == "test"){
+            return this.#topicPatternMatcher.bind(this)
+        }else{
+            return null;
+        }
+    }
 }
 
 export const CONNECTED = "CONNECTED";

package/tests/test.js

@@ -1,5 +1,4 @@
 import { Realtime, CONNECTED, RECONNECT, DISCONNECTED, MESSAGE_RESEND } from "../realtime/realtime.js";
-import axios from "axios";
 import { test, before, after } from 'node:test';
 import assert from 'node:assert';
 
@@ -8,8 +7,8 @@ let realTimeEnabled;
 before(async () => {
     // Start server for testing. Run local server!!
     realTimeEnabled = new Realtime({
-        api_key: process.env.user_key,
-        secret: process.env.secret
+        api_key: process.env.AUTH_JWT,
+        secret: process.env.AUTH_SECRET
     });
     await realTimeEnabled.init(false, {
         debug: true
@@ -55,8 +54,8 @@ test("No creds in constructor", async () => {
 
 test('init() function test', async () => {
     var realtime =  new Realtime({
-        api_key: process.env.user_key,
-        secret: process.env.secret
+        api_key: process.env.AUTH_JWT,
+        secret: process.env.AUTH_SECRET
     });
     await realtime.init(true);
 
@@ -148,8 +147,8 @@ test("Retry method test", async () => {
 
 test("get publish retry count test based in init()", async () => {
     var realtime =  new Realtime({
-        api_key: process.env.user_key,
-        secret: process.env.secret
+        api_key: process.env.AUTH_JWT,
+        secret: process.env.AUTH_SECRET
     });
 
     await realtime.init({
@@ -271,8 +270,8 @@ test("Testing publish(topic, data) with invalid inputs", async () => {
 
 test("on() test", async () => {
     var realtime = new Realtime({
-        api_key: process.env.user_key,
-        secret: process.env.secret
+        api_key: process.env.AUTH_JWT,
+        secret: process.env.AUTH_SECRET
     });
 
     await assert.rejects(async () => {
@@ -349,8 +348,8 @@ test("on() test", async () => {
 
 test("off() test", async () => {
     var realtime = new Realtime({
-        api_key: process.env.user_key,
-        secret: process.env.secret
+        api_key: process.env.AUTH_JWT,
+        secret: process.env.AUTH_SECRET
     });
 
     await assert.rejects(async () => {
@@ -397,8 +396,8 @@ test("off() test", async () => {
 
 test("Get stream name test", () => {
     var realtime = new Realtime({
-        api_key: process.env.user_key,
-        secret: process.env.secret
+        api_key: process.env.AUTH_JWT,
+        secret: process.env.AUTH_SECRET
     });
 
     realtime.namespace = "spacex-dragon-program"
@@ -449,10 +448,82 @@ test("Test isTopicValidMethod()", () => {
         assert.strictEqual(valid, false);
     });
 
-    var unreservedValidTopics = ["hello", "test-room", "heyyyyy", "room-connect"]; 
+    unreservedInvalidTopics = [
+        "$foo",
+        "foo$",
+        "foo.$.bar",
+        "foo..bar",
+        ".foo",
+        "foo.",
+        "foo.>.bar",
+        ">foo",
+        "foo>bar",
+        "foo.>bar",
+        "foo.bar.>.",
+        "foo bar",
+        "foo/bar",
+        "foo#bar",
+        "",
+        " ",
+        "..",
+        ".>",
+        "foo..",
+        ".",
+        ">.",
+        "foo,baz",
+        "αbeta",
+        "foo|bar",
+        "foo;bar",
+        "foo:bar",
+        "foo%bar",
+        "foo.*.>.bar",
+        "foo.*.>.",
+        "foo.*..bar",
+        "foo.>.bar",
+        "foo>"
+    ];
+        
+    unreservedInvalidTopics.forEach(topic => {
+        var valid = realTimeEnabled.isTopicValid(topic);
+        assert.strictEqual(valid, false);
+    });
+
+    var unreservedValidTopics = [
+        "foo",
+        "foo.bar",
+        "foo.bar.baz",
+        "*",
+        "foo.*",
+        "*.bar",
+        "foo.*.baz",
+        ">",
+        "foo.>",
+        "foo.bar.>",
+        "*.*.>",
+        "alpha_beta",
+        "alpha-beta",
+        "alpha~beta",
+        "abc123",
+        "123abc",
+        "~",
+        "alpha.*.>",
+        "alpha.*",
+        "alpha.*.*",
+        "-foo",
+        "foo_bar-baz~qux",
+        "A.B.C",
+        "sensor.temperature",
+        "metric.cpu.load",
+        "foo.*.*",
+        "foo.*.>",
+        "foo_bar.*",
+        "*.*",
+        "metrics.>"
+    ]; 
 
     unreservedValidTopics.forEach(topic => {
         var valid = realTimeEnabled.isTopicValid(topic);
+        console.log(topic)
         assert.strictEqual(valid, true);
     });
 });
@@ -511,4 +582,77 @@ test("History test", async () => {
     },
     new Error("$start must be a Date object"),
     "Expected error was not thrown");
+})
+
+test("Pattern matcher test", async () => {
+    var cases = [
+        ["foo",                 "foo",                      true],   // 1
+        ["foo",                 "bar",                      false],  // 2
+        ["foo.*",               "foo.bar",                  true],   // 3
+        ["foo.bar",             "foo.*",                    true],   // 4
+        ["*",                   "token",                    true],   // 5
+        ["*",                   "*",                        true],   // 6
+        ["foo.*",               "foo.bar.baz",              false],  // 7
+        ["foo.>",               "foo.bar.baz",              true],   // 8
+        ["foo.>",               "foo",                      false],  // 9  (zero‑token '>' now invalid)
+        ["foo.bar.baz",         "foo.>",                    true],   // 10
+        ["foo.bar.>",           "foo.bar",                  false],  // 11
+        ["foo",                 "foo.>",                    false],  // 12
+        ["foo.*.>",             "foo.bar.baz.qux",          true],   // 13
+        ["foo.*.baz",           "foo.bar.>",                true],   // 14
+        ["alpha.*",             "beta.gamma",               false],  // 15
+        ["alpha.beta",          "alpha.*.*",                false],  // 16
+        ["foo.>.bar",           "foo.any.bar",              false],  // 17  ('>' mid‑pattern)
+        [">",                   "foo.bar",                  true],   // 18
+        [">",                   ">",                        true],   // 19
+        ["*",                   ">",                        true],   // 20
+        ["*.>",                 "foo.bar",                  true],   // 21
+        ["*.*.*",               "a.b.c",                    true],   // 22
+        ["*.*.*",               "a.b",                      false],  // 23
+        ["a.b.c.d.e",           "a.b.c.d.e",                true],   // 24
+        ["a.b.c.d.e",           "a.b.c.d.f",                false],  // 25
+        ["a.b.*.d",             "a.b.c.d",                  true],   // 26
+        ["a.b.*.d",             "a.b.c.e",                  false],  // 27
+        ["a.b.>",               "a.b",                      false],  // 28
+        ["a.b",                 "a.b.c.d.>",               false],  // 29
+        ["a.b.>.c",             "a.b.x.c",                  false],  // 30
+        ["a.*.*",               "a.b",                      false],  // 31
+        ["a.*",                 "a.b.c",                    false],  // 32
+        ["metrics.cpu.load",    "metrics.*.load",           true],   // 33
+        ["metrics.cpu.load",    "metrics.cpu.*",            true],   // 34
+        ["metrics.cpu.load",    "metrics.>.load",           false],  // 35
+        ["metrics.>",           "metrics",                  false],  // 36
+        ["metrics.>",           "othermetrics.cpu",         false],  // 37
+        ["*.*.>",               "a.b",                      false],  // 38
+        ["*.*.>",               "a.b.c.d",                  true],   // 39
+        ["a.b.c",               "*.*.*",                    true],   // 40
+        ["a.b.c",               "*.*",                      false],  // 41
+        ["alpha.*.>",           "alpha",                    false],  // 42
+        ["alpha.*.>",           "alpha.beta",               false],  // 43
+        ["alpha.*.>",           "alpha.beta.gamma",         true],   // 44
+        ["alpha.*.>",           "beta.alpha.gamma",         false],  // 45
+        ["foo-bar_baz",         "foo-bar_baz",              true],   // 46
+        ["foo-bar_*",           "foo-bar_123",              false],  // 47 ( '*' here is literal )
+        ["foo-bar_*",           "foo-bar_*",                true],   // 48
+        ["order-*",             "order-123",                false],  // 49
+        ["hello.hey.*",         "hello.hey.>",              true]    // 50
+    ];
+
+    var realtime = new Realtime({
+        api_key: process.env.AUTH_JWT,
+        secret: process.env.AUTH_SECRET
+    });
+
+    var patternMatcher = realtime.testPatternMatcher();
+
+    cases.forEach(testCase => {
+        var tokenA = testCase[0];
+        var tokenB = testCase[1];
+        var expectedResult = testCase[2];
+
+        console.log(`${tokenA}  ⇆  ${tokenB}  → ${expectedResult}`)
+
+        var result = patternMatcher(tokenA, tokenB)
+        assert.strictEqual(expectedResult, result)
+    });
 })