relayx-js 1.0.16 → 1.0.17

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+V1.0.16
+- Wildcard topics for pub / sub fixes
+- Unit tests added for wildcard pattern matching
+
 V1.0.16
 - URL Fix
 

package/examples/example_chat.js

@@ -28,13 +28,26 @@ async function run(){
         console.log(`[IMPL] DISONNECT`)
     });
 
-    await realtime.on("power-telemetry", (data) => {
-        console.log("power-telemetry", data);
-    });
-
-    await realtime.on("hello.*", (data) => {
-        console.log("hello.*", data);
-    });
+    // await realtime.on("power-telemetry", (data) => {
+    //     console.log("power-telemetry", data);
+    // });
+
+    // await realtime.on("hello.*", (data) => {
+    //     console.log("hello.*", data);
+    // });
+
+    // await realtime.on("hello.>", async (data) => {
+    //     await realtime.sleep(10000)
+    //     console.log("hello.>", data);
+    // });
+
+    // await realtime.on("hello.hey.*", (data) => {
+    //     console.log("hell.hey.*", data);
+    // });
+
+    // await realtime.on("hello.hey.>", (data) => {
+    //     console.log("hello.hey.>", data);
+    // });
 
     realtime.on(MESSAGE_RESEND, (data) => {
         console.log(`[MSG RESEND] => ${data}`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relayx-js",
-  "version": "1.0.16",
+  "version": "1.0.17",
   "main": "realtime/realtime.js",
   "type": "module",
   "scripts": {

package/realtime/realtime.js

@@ -12,6 +12,7 @@ export class Realtime {
     #codec = JSONCodec();
     #jetstream = null;
     #consumerMap = {};
+    #consumer = null;
 
     #event_func = {}; 
     #topicMap = []; 
@@ -232,7 +233,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){
@@ -291,13 +291,17 @@ export class Realtime {
     /**
      * Closes connection
      */
-    close(){
+    async close(){
         if(this.#natsClient !== null){
             this.reconnected = false;
             this.disconnected = true;
             
+            this.#consumer?.delete()
+            
             this.#offlineMessageBuffer.length = 0;
 
+            await this.#deleteConsumer();
+
             this.#natsClient.close();
         }else{
             this.#log("Null / undefined socket, cannot close connection");
@@ -308,10 +312,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(); 
+        }
     }
 
     /**
@@ -332,8 +335,6 @@ export class Realtime {
         this.#topicMap = this.#topicMap.filter(item => item !== topic);
 
         delete this.#event_func[topic];
-
-        return await this.#deleteConsumer(topic);
     }
 
     /**
@@ -476,6 +477,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}`)
         }
@@ -576,40 +581,48 @@ export class Realtime {
      * Starts consumer for particular topic if stream exists
      * @param {string} topic 
      */
-    async #startConsumer(topic){
-        this.#log(`Starting consumer for topic: ${topic}_${uuidv4()}`)
+    async #startConsumer(){
+        if(this.#consumer != null){
+            return;
+        }
 
         var opts = { 
-            name: `${topic}_${uuidv4()}`,
-            filter_subjects: [this.#getStreamTopic(topic)],
+            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();
@@ -617,30 +630,22 @@ export class Realtime {
                     await this.#logLatency(now, data);
                 }catch(err){
                     this.#log("Consumer err " + err);
-                    msg.nack(5000);
+                    msg.nak(5000);
                 }
             }
         });
         this.#log("Consumer is consuming");
     }
 
-    /**
-     * 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;
     }
 
@@ -743,7 +748,7 @@ export class Realtime {
             var arrayCheck = ![CONNECTED, DISCONNECTED, RECONNECT, this.#RECONNECTED,
                 this.#RECONNECTING, this.#RECONN_FAIL, MESSAGE_RESEND, SERVER_DISCONNECT].includes(topic);
 
-            const TOPIC_REGEX = /^(?!\$)[A-Za-z0-9_,.*>\$-]+$/;
+            const TOPIC_REGEX = /^(?!.*\$)(?:[A-Za-z0-9_*~-]+(?:\.[A-Za-z0-9_*~-]+)*(?:\.>)?|>)$/u;
 
             var spaceStarCheck = !topic.includes(" ") && TOPIC_REGEX.test(topic);
 
@@ -800,6 +805,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));
     }
@@ -930,6 +1020,14 @@ export class Realtime {
             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

@@ -476,36 +476,38 @@ test("Test isTopicValidMethod()", () => {
     });
 
     unreservedInvalidTopics = [
-        '$internal',          // starts with $
-        'hello world',        // space
-        'topic/',             // slash
-        'name?',              // ?
-        'foo#bar',            // #
-        'bar.baz!',           // !
-        ' space',             // leading space
-        'tab\tchar',          // tab
-        'line\nbreak',        // newline
-        'comma ,',            // space + comma
-        '',                   // empty string
-        'bad|pipe',           // |
-        'semi;colon',         // ;
-        'colon:here',         // :
-        "quote's",            // '
-        '"doublequote"',      // "
-        'brackets[]',         // []
-        'brace{}',            // {}
-        'paren()',            // ()
-        'plus+sign',          // +
-        'eq=val',             // =
-        'gt>lt<',             // < mixed with >
-        'percent%',           // %
-        'caret^',             // ^
-        'ampersand&',         // &
-        'back\\slash',        // backslash
-        '中文字符',            // non‑ASCII
-        '👍emoji',            // emoji
-        'foo\rbar',           // carriage return
-        'end '                // trailing space
+        "$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 => {
@@ -514,40 +516,41 @@ test("Test isTopicValidMethod()", () => {
     });
 
     var unreservedValidTopics = [
-        'Orders',
-        'customer_123',
-        'foo-bar',
-        'a,b,c',
-        '*',
-        'foo>*',
-        'hello$world',
-        'topic.123',
-        'ABC_def-ghi',
-        'data_stream_2025',
-        'NODE*',
-        'pubsub>events',
-        'log,metric,error',
-        'X123_Y456',
-        'multi.step.topic',
-        'batch-process',
-        'sensor1_data',
-        'finance$Q2',
-        'alpha,beta,gamma',
-        'Z9_Y8-X7',
-        'config>*',
-        'route-map',
-        'STATS_2025-07',
-        'msg_queue*',
-        'update>patch',
-        'pipeline_v2',
-        'FOO$BAR$BAZ',
-        'user.profile',
-        'id_001-xyz',
-        'event_queue>'
+        "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);
     });
 });
@@ -606,4 +609,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)
+    });
+})