relayx-js 1.0.16 → 1.0.18

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

@@ -32,10 +32,22 @@ async function run(){
         console.log("power-telemetry", data);
     });
 
-    await realtime.on("hello.*", (data) => {
-        console.log("hello.*", data);
+    // await realtime.on("hello.*", (data) => {
+    //     console.log("hello.*", 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}`)
     });

package/package.json

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

package/realtime/realtime.js

@@ -16,13 +16,13 @@ export class Realtime {
     #event_func = {}; 
     #topicMap = []; 
 
-    #config = "CiAgICAgICAgLS0tLS1CRUdJTiBOQVRTIFVTRVIgSldULS0tLS0KICAgICAgICBKV1RfS0VZCiAgICAgICAgLS0tLS0tRU5EIE5BVFMgVVNFUiBKV1QtLS0tLS0KCiAgICAgICAgKioqKioqKioqKioqKioqKioqKioqKioqKiBJTVBPUlRBTlQgKioqKioqKioqKioqKioqKioqKioqKioqKgogICAgICAgIE5LRVkgU2VlZCBwcmludGVkIGJlbG93IGNhbiBiZSB1c2VkIHRvIHNpZ24gYW5kIHByb3ZlIGlkZW50aXR5LgogICAgICAgIE5LRVlzIGFyZSBzZW5zaXRpdmUgYW5kIHNob3VsZCBiZSB0cmVhdGVkIGFzIHNlY3JldHMuCgogICAgICAgIC0tLS0tQkVHSU4gVVNFUiBOS0VZIFNFRUQtLS0tLQogICAgICAgIFNFQ1JFVF9LRVkKICAgICAgICAtLS0tLS1FTkQgVVNFUiBOS0VZIFNFRUQtLS0tLS0KCiAgICAgICAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICAgICAgIA=="
-
     // Status Codes
     #RECONNECTING = "RECONNECTING";
     #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; 
 
@@ -42,6 +42,8 @@ export class Realtime {
 
     #maxPublishRetries = 5; 
 
+    #connectCalled = false;
+
     constructor(config){
         if(typeof config != "object"){
             throw new Error("Realtime($config). $config not object => {}")
@@ -97,10 +99,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;
@@ -171,6 +176,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)
@@ -194,6 +203,7 @@ export class Realtime {
             await this.#getNameSpace()
 
             this.connected = true;
+            this.#connectCalled = true;
         }catch(err){
             this.#log("ERR")
             this.#log(err);
@@ -204,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){
@@ -232,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");
@@ -268,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);   
@@ -285,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");
@@ -314,6 +324,17 @@ export class Realtime {
         });
     }
 
+    /**
+     * 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.
      * This will stop listening to a topic
@@ -359,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;
@@ -413,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")
         }
 
@@ -428,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)}`)
     
@@ -463,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");
         }
@@ -476,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}`)
         }
@@ -496,11 +506,16 @@ export class Realtime {
             end = end.toISOString();
         }
 
+        if(!this.connected){
+            return [];
+        }
+
         var opts = { 
             name: `${topic}_${uuidv4()}_history`,
             filter_subjects: [this.#getStreamTopic(topic)],
             replay_policy: ReplayPolicy.Instant,
             opt_start_time: start,
+            delivery_policy: DeliverPolicy.StartTime,
             ack_policy: AckPolicy.Explicit,
         }
 
@@ -529,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();
@@ -577,10 +597,10 @@ export class Realtime {
      * @param {string} topic 
      */
     async #startConsumer(topic){
-        this.#log(`Starting consumer for topic: ${topic}_${uuidv4()}`)
+        const consumerName = `${topic}_${uuidv4()}_consumer`;
 
         var opts = { 
-            name: `${topic}_${uuidv4()}`,
+            name: consumerName,
             filter_subjects: [this.#getStreamTopic(topic)],
             replay_policy: ReplayPolicy.Instant,
             opt_start_time: new Date(),
@@ -597,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();
@@ -617,18 +643,15 @@ 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){
+        this.#log(topic)
         const consumer = this.#consumerMap[topic]
 
         var del = false;
@@ -650,11 +673,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}`);
@@ -671,7 +689,7 @@ export class Realtime {
             this.#latencyPush = setTimeout(async () => {
                 this.#log("setTimeout called");
 
-                if(this.#latency.length > 0 && this.connected){
+                if(this.#latency.length > 0 && this.connected && !this.#isSendingLatency){
                     this.#log("Push from setTimeout")
                     await this.#pushLatencyData({
                         timezone: timeZone,
@@ -684,7 +702,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,
@@ -740,10 +758,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);
 
@@ -753,7 +770,7 @@ export class Realtime {
         }
     }
 
-    #isMessageValid(message){
+    isMessageValid(message){
         if(message == null || message == undefined){
             throw new Error("$message cannot be null / undefined")
         }
@@ -800,6 +817,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));
     }
@@ -865,13 +967,21 @@ export class Realtime {
         return methodDataOutput;
     }
 
-    #getUserCreds(jwt, secret){
-        var template = Buffer.from(this.#config, "base64").toString("utf8")
+     #getUserCreds(jwt, secret){
+        return `
+-----BEGIN NATS USER JWT-----
+${jwt}
+------END NATS USER JWT------
+
+************************* IMPORTANT *************************
+NKEY Seed printed below can be used to sign and prove identity.
+NKEYs are sensitive and should be treated as secrets.
 
-        var creds = template.replace("JWT_KEY", jwt);
-        creds = creds.replace("SECRET_KEY", secret)
+-----BEGIN USER NKEY SEED-----
+${secret}
+------END USER NKEY SEED------
 
-        return creds
+*************************************************************`
     }
 
     // Exposure for tests
@@ -930,6 +1040,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)
+    });
+})