relayx-webjs 1.0.1 → 1.0.3

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+V1.0.2
+- Wildcard topics for pub / sub fixes
+- Unit tests added for wildcard pattern matching
+
 V1.0.1
 - Wildcard topics for pub / sub
 - Message replay on reconnection

package/example/chat-app/package.json

@@ -5,7 +5,8 @@
   "scripts": {
     "dev": "vite",
     "build": "vite build",
-    "preview": "vite preview"
+    "preview": "vite preview",
+    "preview-proxy": "PROXY=true vite preview"
   },
   "dependencies": {
     "react": "^18.2.0",

package/example/stand-alone/example_chat.js

@@ -0,0 +1,111 @@
+import { Realtime, CONNECTED, RECONNECT, DISCONNECTED, MESSAGE_RESEND } from "../../realtime/realtime.js"
+import * as readline from 'readline';
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+async function run(){
+    var realtime = new Realtime({
+        api_key: process.env.AUTH_JWT,
+        secret: process.env.AUTH_SECRET
+    });
+    await realtime.init(false, {
+        max_retries: 2,
+        debug: true
+    });
+
+    realtime.on(CONNECTED, async () => {
+        console.log("[IMPL] => CONNECTED!");
+    });
+
+    realtime.on(RECONNECT, (status) => {
+        console.log(`[IMPL] RECONNECT => ${status}`)
+    });
+
+    realtime.on(DISCONNECTED, () => {
+        console.log(`[IMPL] DISONNECT`)
+    });
+
+    await realtime.on("power-telemetry", (data) => {
+        console.log("power-telemetry", data);
+    });
+
+    await realtime.on("hello.>", async (data) => {
+        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}`)
+    });
+
+    rl.on('line', async (input) => {
+        console.log(`You entered: ${input}`);
+
+        if(input == "exit"){
+            var output = await realtime.off("hello"); 
+            console.log(output);
+
+            realtime.close();
+
+            process.exit();
+        }else if(input == "history"){
+            rl.question("topic: ", async (topic) => {
+                var start = new Date();
+                var past = start.setDate(start.getDate() - 4)
+                var pastDate = new Date(past)
+
+                var end = new Date();
+                var past = end.setDate(end.getDate())
+                var endDate = new Date(past)
+
+                var history = await realtime.history(topic, pastDate)
+                console.log(history)
+            })
+        }else if(input == "off"){
+            rl.question("topic to off(): ", async (topic) => {
+                await realtime.off(topic);
+                console.log("off() executed")
+            })
+
+            
+        }else if(input == "close"){
+            realtime.close();
+            console.log("Connection closed");
+        }else if(input == "init"){
+            await realtime.connect()
+        }else if(input == "on"){
+            rl.question("topic: ", async (topic) => {
+                await realtime.on(topic, (data) => {
+                    console.log(topic, data);
+                });
+            })
+        }else{
+            rl.question("topic: ", async (topic) => {
+                var output = await realtime.publish(topic, input);
+            })
+        }
+    });
+
+    realtime.connect();
+
+    process.on('SIGINT', async () => {
+        console.log('Keyboard interrupt detected (Ctrl+C). Cleaning up...');
+        // Perform any necessary cleanup here
+    
+        // Exit the process
+        process.exit();
+    });
+    
+}
+
+await run();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relayx-webjs",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "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/dns_change.js

@@ -0,0 +1,20 @@
+import dns from 'node:dns';
+
+export function initDNSSpoof(){
+    const originalLookup = dns.lookup;
+
+    // Override for the whole process
+    dns.lookup = function patchedLookup(hostname, options, callback) {
+
+    // ── Our one special case ──────────────────────────────────
+    if (hostname === 'api2.relay-x.io') {
+        // Map to loop‑back; family 4 avoids ::1
+        return process.nextTick(() =>
+        callback(null, [{address: '127.0.0.1', family: 4}])
+        );
+    }
+
+    // Anything else → real DNS
+    return originalLookup.call(dns, hostname, options, callback);
+    };
+}

package/realtime/realtime.js

@@ -2,6 +2,7 @@ import { connect, JSONCodec, Events, DebugEvents, AckPolicy, ReplayPolicy, creds
 import { DeliverPolicy, jetstream } from "@nats-io/jetstream";
 import { encode, decode } from "@msgpack/msgpack";
 import { v4 as uuidv4 } from 'uuid';
+import { initDNSSpoof } from "./dns_change.js";
 
 export class Realtime {
 
@@ -11,6 +12,7 @@ export class Realtime {
     #codec = JSONCodec();
     #jetstream = null;
     #consumerMap = {};
+    #consumer = null;
 
     #event_func = {}; 
     #topicMap = []; 
@@ -20,6 +22,8 @@ export class Realtime {
     #RECONNECTED = "RECONNECTED";
     #RECONN_FAIL = "RECONN_FAIL";
 
+    #reservedSystemTopics = [CONNECTED, DISCONNECTED, RECONNECT, this.#RECONNECTED, this.#RECONNECTING, this.#RECONN_FAIL, MESSAGE_RESEND, SERVER_DISCONNECT];
+
     setRemoteUserAttempts = 0;
     setRemoteUserRetries = 5; 
 
@@ -39,6 +43,8 @@ export class Realtime {
 
     #maxPublishRetries = 5; 
 
+    #connectCalled = false;
+
     constructor(config){
         if(typeof config != "object"){
             throw new Error("Realtime($config). $config not object => {}")
@@ -94,10 +100,13 @@ export class Realtime {
             if(arguments[0] instanceof Object){
                 opts = arguments[0];
                 staging = false;
-            }else{
+            }else if(typeof arguments[0] == "boolean"){
                 opts = {};
                 staging = arguments[0];
                 this.#log(staging)
+            }else{
+                opts = {};
+                staging = false
             }
         }else{
             staging = false;
@@ -107,23 +116,28 @@ export class Realtime {
         this.staging = staging; 
         this.opts = opts;
 
-        if (staging !== undefined || staging !== null){
-            this.#baseUrl = staging ? [
-                "nats://0.0.0.0:4421",
-                "nats://0.0.0.0:4422",
-                "nats://0.0.0.0:4423"
-                ] : 
-                [
+        if(process.env.PROXY){
+            this.#baseUrl = ["wss://api2.relay-x.io:8666"];
+            initDNSSpoof();
+        }else{
+            if (staging !== undefined || staging !== null){
+                this.#baseUrl = staging ? [
+                    "nats://0.0.0.0:4421",
+                    "nats://0.0.0.0:4422",
+                    "nats://0.0.0.0:4423"
+                    ] : 
+                    [
+                        `wss://api.relay-x.io:4421`,
+                        `wss://api.relay-x.io:4422`,
+                        `wss://api.relay-x.io:4423`
+                    ];
+            }else{
+                this.#baseUrl = [
                     `wss://api.relay-x.io:4421`,
                     `wss://api.relay-x.io:4422`,
                     `wss://api.relay-x.io:4423`
                 ];
-        }else{
-            this.#baseUrl = [
-                `wss://api.relay-x.io:4421`,
-                `wss://api.relay-x.io:4422`,
-                `wss://api.relay-x.io:4423`
-            ];
+            }
         }
 
         this.#log(this.#baseUrl);
@@ -163,6 +177,10 @@ export class Realtime {
      * Connects to the relay network
      */
     async connect(){
+        if(this.#connectCalled){
+            return;
+        }
+
         this.SEVER_URL = this.#baseUrl;
 
         var credsFile = this.#getUserCreds(this.api_key, this.secret)
@@ -177,7 +195,7 @@ export class Realtime {
                 maxReconnectAttempts: 1200,
                 reconnectTimeWait: 1000,
                 authenticator: credsAuth,
-                token: this.api_key,
+                token: this.api_key
             });
 
             this.#jetstream = await jetstream(this.#natsClient);
@@ -185,6 +203,7 @@ export class Realtime {
             await this.#getNameSpace()
 
             this.connected = true;
+            this.#connectCalled = true;
         }catch(err){
             this.#log("ERR")
             this.#log(err);
@@ -195,17 +214,13 @@ export class Realtime {
         if (this.connected == true){
             this.#log("Connected to server!");
 
-            // Callback on client side
-            if (CONNECTED in this.#event_func){
-                if (this.#event_func[CONNECTED] !== null || this.#event_func[CONNECTED] !== undefined){
-                    this.#event_func[CONNECTED]()
-                }
-            }
-
             this.#natsClient.closed().then(() => {
                 this.#log("the connection closed!");
 
                 this.#offlineMessageBuffer.length = 0;
+                this.connected = false;
+                this.reconnecting = false;
+                this.#connectCalled = false;
 
                 if (DISCONNECTED in this.#event_func){
                     if (this.#event_func[DISCONNECTED] !== null || this.#event_func[DISCONNECTED] !== undefined){
@@ -223,13 +238,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){
-                                this.#event_func[DISCONNECTED]()
-                            }
-                        }
                     break;
                     case Events.LDM:
                         this.#log("client has been requested to reconnect");
@@ -259,6 +267,7 @@ export class Realtime {
                         this.#log("client is attempting to reconnect");
 
                         this.reconnecting = true;
+                        this.connected = false;
 
                         if(RECONNECT in this.#event_func && this.reconnecting){
                             this.#event_func[RECONNECT](this.#RECONNECTING);   
@@ -276,19 +285,29 @@ export class Realtime {
             // Subscribe to topics
             this.#subscribeToTopics();
             this.#log("Subscribed to topics");
+
+            // Callback on client side
+            if (CONNECTED in this.#event_func){
+                if (this.#event_func[CONNECTED] !== null || this.#event_func[CONNECTED] !== undefined){
+                    this.#event_func[CONNECTED]()
+                }
+            }
         }
     }
 
     /**
      * Closes connection
      */
-    close(){
+    async close(){
         if(this.#natsClient !== null){
             this.reconnected = false;
             this.disconnected = true;
+            this.#connectCalled = false;
             
             this.#offlineMessageBuffer.length = 0;
 
+            await this.#deleteAllConsumers();
+
             this.#natsClient.close();
         }else{
             this.#log("Null / undefined socket, cannot close connection");
@@ -304,6 +323,17 @@ export class Realtime {
             await this.#startConsumer(topic); 
         });
     }
+    
+    /**
+     * Delete consumers for topics initialized by user
+     */
+    async #deleteAllConsumers(){
+        for(let i = 0; i < this.#topicMap.length; i++){
+            let topic = this.#topicMap[i];
+
+            await this.#deleteConsumer(topic); 
+        }
+    }
 
     /**
      * Deletes reference to user defined event callback.
@@ -350,31 +380,23 @@ export class Realtime {
             throw new Error(`Expected $topic type -> string. Instead receieved -> ${typeof topic}`);
         }
 
-        if(!(topic in this.#event_func)){
-            this.#event_func[topic] = func;
-        }else{
+        if(topic in this.#event_func || this.#topicMap.includes(topic)){
             return false
         }
 
-        if (![CONNECTED, DISCONNECTED, RECONNECT, this.#RECONNECTED,
-            this.#RECONNECTING, this.#RECONN_FAIL, MESSAGE_RESEND, SERVER_DISCONNECT].includes(topic)){
-                if(!this.isTopicValid(topic)){
-                    // We have an invalid topic, lets remove it
-                    if(topic in this.#event_func){
-                        delete this.#event_func[topic];
-                    }
+        this.#event_func[topic] = func;
 
-                    throw new Error("Invalid topic, use isTopicValid($topic) to validate topic")
-                }
+        if (!this.#reservedSystemTopics.includes(topic)){
+            if(!this.isTopicValid(topic)){
+                throw new Error("Invalid topic, use isTopicValid($topic) to validate topic")
+            }
 
-                if(!this.#topicMap.includes(topic)){
-                    this.#topicMap.push(topic);
-                }
+            this.#topicMap.push(topic);
 
-                if(this.connected){
-                    // Connected we need to create a topic in a stream
-                    await this.#startConsumer(topic);
-                }
+            if(this.connected){
+                // Connected we need to create a topic in a stream
+                await this.#startConsumer(topic);
+            }
         }
 
         return true;
@@ -404,7 +426,7 @@ export class Realtime {
             throw new Error("Invalid topic, use isTopicValid($topic) to validate topic")
         }
 
-        if(!this.#isMessageValid(data)){
+        if(!this.isMessageValid(data)){
             throw new Error("$message must be JSON, string or number")
         }
 
@@ -419,15 +441,9 @@ export class Realtime {
             "start": Date.now()
         }
 
-        this.#log("Encoding message via msg pack...")
-        var encodedMessage = encode(message);
-
         if(this.connected){
-            if(!this.#topicMap.includes(topic)){
-                this.#topicMap.push(topic);
-            }else{
-                this.#log(`${topic} exists locally, moving on...`)
-            }
+            this.#log("Encoding message via msg pack...")
+            var encodedMessage = encode(message);
 
             this.#log(`Publishing to topic => ${this.#getStreamTopic(topic)}`)
     
@@ -454,7 +470,6 @@ export class Realtime {
      * @param {string} topic 
      */
     async history(topic, start, end){
-        this.#log(start)
         if(topic == null || topic == undefined){
             throw new Error("$topic is null or undefined");
         }
@@ -467,6 +482,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}`)
         }
@@ -487,11 +506,16 @@ export class Realtime {
             end = end.toISOString();
         }
 
+        if(!this.connected){
+            return [];
+        }
+
         var opts = { 
-            name: `${topic}_${uuidv4()}_history`,
+            name: `webjs_${topic}_${uuidv4()}_history_consumer`,
             filter_subjects: [this.#getStreamTopic(topic)],
             replay_policy: ReplayPolicy.Instant,
             opt_start_time: start,
+            delivery_policy: DeliverPolicy.StartTime,
             ack_policy: AckPolicy.Explicit,
         }
 
@@ -520,7 +544,12 @@ export class Realtime {
             var data = decode(msg.data);
             this.#log(data);
             
-            history.push(data.message);
+            history.push({
+                "id": data.id,
+                "topic": data.room,
+                "message": data.message,
+                "timestamp": msg.timestamp
+            });
         }
 
         var del = await consumer.delete();
@@ -568,11 +597,11 @@ export class Realtime {
      * @param {string} topic 
      */
     async #startConsumer(topic){
-        this.#log(`Starting consumer for topic: ${topic}_${uuidv4()}`)
+        const consumerName = `webjs_${topic}_${uuidv4()}_consumer`;
 
         var opts = { 
-            name: `${topic}_${uuidv4()}`,
-            filter_subjects: [this.#getStreamTopic(topic), this.#getStreamTopic(topic) + "_presence"],
+            name: consumerName,
+            filter_subjects: [this.#getStreamTopic(topic)],
             replay_policy: ReplayPolicy.Instant,
             opt_start_time: new Date(),
             ack_policy: AckPolicy.Explicit,
@@ -588,19 +617,25 @@ export class Realtime {
             callback: async (msg) => {
                 try{
                     const now = Date.now();
+                    msg.working()
                     this.#log("Decoding msgpack message...")
                     var data = decode(msg.data);
 
-                    var room = data.room;
+                    var msgTopic = 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 topicMatch = this.#topicPatternMatcher(topic, msgTopic)
+
+                        if(topicMatch){
+                            this.#event_func[topic]({
+                                "id": data.id,
+                                "topic": msgTopic,
+                                "data": data.message
+                            });
+                        }
                     }
 
                     msg.ack();
@@ -608,7 +643,7 @@ export class Realtime {
                     await this.#logLatency(now, data);
                 }catch(err){
                     this.#log("Consumer err " + err);
-                    msg.nack(5000);
+                    msg.nak(5000);
                 }
             }
         });
@@ -620,6 +655,7 @@ export class Realtime {
      * @param {string} topic 
      */
     async #deleteConsumer(topic){
+        this.#log(topic)
         const consumer = this.#consumerMap[topic]
 
         var del = false;
@@ -641,11 +677,6 @@ export class Realtime {
             return;
         }
 
-        if(this.#latency.length >= 100){
-            this.#log("Latency array is full, skipping log");
-            return;
-        }
-
         const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
 
         this.#log(`Timezone: ${timeZone}`);
@@ -662,7 +693,7 @@ export class Realtime {
             this.#latencyPush = setTimeout(async () => {
                 this.#log("setTimeout called");
 
-                if(this.#latency.length > 0){
+                if(this.#latency.length > 0 && this.connected && !this.#isSendingLatency){
                     this.#log("Push from setTimeout")
                     await this.#pushLatencyData({
                         timezone: timeZone,
@@ -675,7 +706,7 @@ export class Realtime {
             }, 30000);
         }
 
-        if(this.#latency.length == 100 && !this.#isSendingLatency){
+        if(this.#latency.length >= 100 && !this.#isSendingLatency){
             this.#log("Push from Length Check: " + this.#latency.length);
             await this.#pushLatencyData({
                         timezone: timeZone,
@@ -731,10 +762,9 @@ export class Realtime {
      */
     isTopicValid(topic){
         if(topic !== null && topic !== undefined && (typeof topic) == "string"){
-            var arrayCheck = ![CONNECTED, DISCONNECTED, RECONNECT, this.#RECONNECTED,
-                this.#RECONNECTING, this.#RECONN_FAIL, MESSAGE_RESEND, SERVER_DISCONNECT].includes(topic);
+            var arrayCheck = !this.#reservedSystemTopics.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);
 
@@ -744,7 +774,7 @@ export class Realtime {
         }
     }
 
-    #isMessageValid(message){
+    isMessageValid(message){
         if(message == null || message == undefined){
             throw new Error("$message cannot be null / undefined")
         }
@@ -791,6 +821,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));
     }
@@ -929,6 +1044,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

@@ -449,36 +449,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 => {
@@ -487,40 +489,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);
     });
 });
@@ -579,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)
+    });
 })