entangld 2.1.6 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "entangld",
-  "version": "2.1.6",
+  "version": "2.3.0",
   "description": "Synchronized key-value stores with RPCs and events",
   "main": "index.js",
   "jshintConfig": {
@@ -12,9 +12,9 @@
     "test": "mocha",
     "lint:js": "jshint --reporter=node_modules/jshint-stylish index.js test/",
     "build": "npm run lint:js -s && npm run test -s && npm run docs -s",
-    "watch:lint:js": "nodemon -w index.js -w test/ -x npm run lint:js -s",
-    "dev": "nodemon -w index.js -w test/ -x npm run build -s",
-    "docs": "node generate_docs.js"
+    "docs": "node generate_docs.js",
+    "lint": "npx eslint lib test index.js || true",
+    "lint:fix": "npx eslint --fix lib test index.js || true"
   },
   "repository": {
     "type": "git",
@@ -22,16 +22,15 @@
   },
   "author": "c0d3",
   "contributors": [
-    "Wilkins White <wilkins.white@daxbot.com>",
-    "Jonathan Van Schenck <jon.vanschenck@daxbot.com>"
+    "Wilkins White <ww@novadynamics.com>",
+    "Jonathan Van Schenck <jvschenck@novadynamics.com>"
   ],
   "license": "MIT",
   "homepage": "https://daxbot.com/open-source",
   "devDependencies": {
-    "fs-then-native": "^2.0.0",
+    "eslint": "^8.35.0",
+    "eslint-plugin-node": "^11.1.0",
     "jsdoc-to-markdown": "^7.1.1",
-    "jshint": "^2.13.1",
-    "jshint-stylish": "^2.2.1",
     "mocha": "^10.0.0",
     "nodemon": "^2.0.16",
     "sockhop": "^1.4.3"

package/test/circular.js

@@ -1,9 +1,5 @@
 var Entangld=require("../index.js");
 
-function wait (ms) {
-    return new Promise(res=>setTimeout(res,ms));
-}
-
 describe("Circular References", function() {
     let s,a,b;
 
@@ -23,9 +19,9 @@ describe("Circular References", function() {
     });
 
     afterEach(function() {
-        delete s;
-        delete a;
-        delete b;
+        delete s; // eslint-disable-line no-delete-var
+        delete a; // eslint-disable-line no-delete-var
+        delete b; // eslint-disable-line no-delete-var
     });
 
     it("Circular subscriptions don't break", function(done) {

package/test/events.js

@@ -18,6 +18,29 @@ describe("Events",()=>{
     a.transmit((msg, store)=>store.receive(msg, a));
     b.transmit((msg, store)=>store.receive(msg, b));
 
+
+    // Original tests were written with globals and are thus not independent.  I'm adding (JLS 2023-02-21) some "clean" scaffolding.
+    // TODO - we should eventually rewrite tests to use these new objects.
+    let A,B,S;
+    beforeEach(()=>{
+
+        S=new Entangld();
+        A=new Entangld();
+        B=new Entangld();
+
+        S.attach("a",A);
+        S.attach("b",B);
+
+        A.attach("parent", S);
+        B.attach("parent", S);
+
+        S.transmit((msg, store)=>store.receive(msg, S));
+        A.transmit((msg, store)=>store.receive(msg, A));
+        B.transmit((msg, store)=>store.receive(msg, B));
+
+    });
+
+
     it("Subscribe to local event (exact)", (done)=>{
 
         s.subscribe("my.own.event",(path, val)=>{
@@ -53,6 +76,22 @@ describe("Events",()=>{
         a.set("system.voltage",21);
     });
 
+    it("Subscribe to remote event (wildcard)", (done)=>{
+
+        S.subscribe("a.*.voltage",(path, val)=>{
+
+            assert.strictEqual(path,"a.system.voltage");
+            assert.strictEqual(val, 21);
+
+            // Check for proper internals
+            assert.strictEqual(s._subscriptions.length,1);
+            assert.strictEqual(a._subscriptions.length,1);
+            done();
+        });
+
+        A.set("system.voltage",21);
+    });
+
     it("Subscribe to remote event (descendant of subscribed path also triggers event)", (done)=>{
 
         s.subscribe("a.flowers.roses",(path, val)=>{

package/test/sockets.js

@@ -1,16 +1,16 @@
-const Entangld=require("../index.js");
-const sockhop=require("sockhop");
-const assert=require("assert");
+const Entangld=require("../lib/Datastore.js");
+const sockhop=require("sockhop"); // eslint-disable-line node/no-unpublished-require
 
 function wait (ms) {
     return new Promise(res=>setTimeout(res,ms));
 }
 
 // FIXME : comment out for debugging
-console.log = () => {};
+// const _log = console.log;
+const _log = () => {};
 
 describe("Sockets", function() {
-    let server,client,sock_ref,s,a,b;
+    let server,client,sock_ref,s,a;
 
     beforeEach(function() {
         s = new Entangld();
@@ -19,21 +19,21 @@ describe("Sockets", function() {
         server = new sockhop.server({
             address : "localhost",
             port : 9876
-        })
-        server.on("receive", (o, meta) => { console.log("s.r",o); s.receive(o, meta.socket) } );
+        });
+        server.on("receive", (o, meta) => { _log("s.r",o); s.receive(o, meta.socket); } );
         client = new sockhop.client({
             address : "localhost",
             port : 9876
-        })
-        client.on("receive", (o, meta) => { console.log("c.r",o); a.receive(o, client) });
+        });
+        client.on("receive", (o) => { _log("c.r",o); a.receive(o, client); });
 
 
         s.transmit((msg, socket) => { // server's transmit to net-sockets
-            console.log("s.t",msg);
+            _log("s.t",msg);
             if ( socket.readyState == 'open' ) server.send(socket, msg);
         });
         a.transmit((msg, client) => { // client's transmit to sockhop client
-            console.log("a.t",msg);
+            _log("a.t",msg);
             if ( client.connected ) client.send(msg);
         });
 
@@ -46,11 +46,11 @@ describe("Sockets", function() {
     });
 
     afterEach(function() {
-        delete s;
-        delete a;
+        delete s;  // eslint-disable-line no-delete-var
+        delete a;  // eslint-disable-line no-delete-var
         server.close();
-        delete server;
-        delete client;
+        delete server; // eslint-disable-line no-delete-var
+        delete client; // eslint-disable-line no-delete-var
     });
 
     it("Can subscribe", function(done) {
@@ -86,7 +86,7 @@ describe("Sockets", function() {
             while ( sock_ref.readyState !== "open" ) await wait(1);
             s.subscribe("path1.a.data");
             while ( a._subscriptions.length < 1 ) await wait(1);
-            s.detach("path1.a")
+            s.detach("path1.a");
             s.attach("path1.a",new Entangld());
             await wait(5); // set messages clear
             if ( a._subscriptions.length !== 0 ) done(new Error("Subscription never removed"));
@@ -102,7 +102,7 @@ describe("Sockets", function() {
             s.subscribe("path1.a.data");
             while ( a._subscriptions.length < 1 ) await wait(1);
             client.disconnect(); // kill the socket
-            s.detach("path1.a")
+            s.detach("path1.a");
             s.attach("path1.a",new Entangld());
             await wait(5); // set messages clear
             if ( a._subscriptions.length !== 1 ) done(new Error("Subscription was removed!?"));
@@ -128,8 +128,8 @@ describe("Sockets", function() {
             client = new sockhop.client({
                 address : "localhost",
                 port : 9876
-            })
-            client.on("receive", (o, meta) => { console.log("c.r",o); a.receive(o, client) });
+            });
+            client.on("receive", (o) => { _log("c.r",o); a.receive(o, client); });
             client.connect();
             while ( !sock_ref ) await wait(1);
             while ( sock_ref.readyState !== "open" ) await wait(1);

package/test/subscriptions.js

@@ -19,9 +19,9 @@ describe("Subscription", function() {
     });
 
     afterEach(function() {
-        delete s;
-        delete a;
-        delete b;
+        delete s; // eslint-disable-line no-delete-var
+        delete a; // eslint-disable-line no-delete-var
+        delete b; // eslint-disable-line no-delete-var
     });
 
     it("Should only trigger subscriptions on an exact match", function(done) {
@@ -35,14 +35,14 @@ describe("Subscription", function() {
     });
 
     it("Should emit on recieved subscriptions (locally)", function(done) {
-        s.on("subscription", ( path, uuid ) => {
+        s.on("subscription", ( path ) => {
             if ( path === "test" ) { done(); return; }
             assert.fail("Subcription yield path " + path);
         });
         s.subscribe('test', () => {});
     });
     it("Should emit on recieved unsubscriptions (locally)", function(done) {
-        s.on("unsubscription", ( path, uuid ) => {
+        s.on("unsubscription", ( path ) => {
             if ( path === "test" ) { done(); return; }
             assert.fail("Subcription yield path " + path);
         });
@@ -51,14 +51,14 @@ describe("Subscription", function() {
     });
 
     it("Should emit on recieved subscriptions (remote)", function(done) {
-        a.on("subscription", ( path, uuid ) => {
+        a.on("subscription", ( path ) => {
             if ( path === "some_data" ) { done(); return; }
             assert.fail("Subcription yield path " + path);
         });
         s.subscribe('path1.A.some_data', () => {});
     });
     it("Should emit on recieved unsubscriptions (remote)", function(done) {
-        a.on("unsubscription", ( path, uuid ) => {
+        a.on("unsubscription", ( path ) => {
             if ( path === "some_data" ) { done(); return; }
             assert.fail("Subcription yield path " + path);
         });
@@ -67,7 +67,7 @@ describe("Subscription", function() {
     });
 
     it("Shouldn't emit on sent subscriptions (remote)", function(done) {
-        s.on("subscription", ( path, uuid ) => {
+        s.on("subscription", () => {
             assert.fail("this shouldn't run");
         });
         s.subscribe('path1.A.path3.B.something', () => {});
@@ -75,7 +75,7 @@ describe("Subscription", function() {
         done();
     });
     it("Shouldn't emit on sent unsubscriptions (remote)", function(done) {
-        s.on("unsubscription", ( path, uuid ) => {
+        s.on("unsubscription", () => {
             assert.fail("this shouldn't run");
         });
         s.subscribe('path1.A.path3.B.something', () => {});
@@ -84,7 +84,7 @@ describe("Subscription", function() {
         done();
     });
     it("Shouldn't emit on passthrough subscriptions (remote)", function(done) {
-        a.on("subscription", ( path, uuid ) => {
+        a.on("subscription", () => {
             assert.fail("this shouldn't run");
         });
         s.subscribe('path1.A.path3.B.something', () => {});
@@ -92,7 +92,7 @@ describe("Subscription", function() {
         done();
     });
     it("Shouldn't emit on passthrough unsubscriptions (remote)", function(done) {
-        a.on("unsubscription", ( path, uuid ) => {
+        a.on("unsubscription", () => {
             assert.fail("this shouldn't run");
         });
         s.subscribe('path1.A.path3.B.something', () => {});
@@ -103,7 +103,7 @@ describe("Subscription", function() {
 
     it("Emit on each subscription", function(done) {
         let count = 0;
-        b.on("subscription", ( path, uuid ) => {
+        b.on("subscription", ( path ) => {
             count += 1;
             assert.strictEqual(path, "something");
         });
@@ -118,8 +118,8 @@ describe("Subscription", function() {
 
         var count = 0;
         // Create two subscriptions
-        s.subscribe("some_data", () => {count += 1});
-        s.subscribe("some_data", () => {count += 1});
+        s.subscribe("some_data", () => {count += 1;});
+        s.subscribe("some_data", () => {count += 1;});
 
         s.set('some_data', 0.0);
 
@@ -130,7 +130,7 @@ describe("Subscription", function() {
 
     it("Can (not) throttle subscription messages (locally)", (done) => {
         var count = 0;
-        s.subscribe("some_data", (path, value) => { count += 1 }, 1)
+        s.subscribe("some_data", () => { count += 1; }, 1);
         for ( let i = 0; i < 10; i ++ ) {
             s.set("some_data", 1);
         }
@@ -140,7 +140,7 @@ describe("Subscription", function() {
 
     it("Can throttle subscription messages (locally)", (done) => {
         var count = 0;
-        s.subscribe("some_data", (path, value) => { count += 1 }, 2)
+        s.subscribe("some_data", () => { count += 1; }, 2);
         for ( let i = 0; i < 10; i ++ ) {
             s.set("some_data", 1);
         }
@@ -150,7 +150,7 @@ describe("Subscription", function() {
 
     it("Can throttle subscription messages (remote)", (done) => {
         var count = 0;
-        s.subscribe("path1.A.path3.B.some_data", (path, value) => { count += 1 }, 2)
+        s.subscribe("path1.A.path3.B.some_data", () => { count += 1; }, 2);
         for ( let i = 0; i < 10; i ++ ) {
             b.set("some_data", 1);
         }
@@ -162,8 +162,8 @@ describe("Subscription", function() {
 
         var count = 0;
         // Create two subscriptions
-        s.subscribe("some_data", () => {count += 1});
-        s.subscribe("some_data", () => {count += 1});
+        s.subscribe("some_data", () => {count += 1;});
+        s.subscribe("some_data", () => {count += 1;});
 
         s.set('some_data', 0.0);
 
@@ -176,8 +176,8 @@ describe("Subscription", function() {
 
         var count = 0;
         // Create two subscriptions
-        s.subscribe("path1.A.some_data", () => {count += 1});
-        s.subscribe("path1.A.some_data", () => {count += 1});
+        s.subscribe("path1.A.some_data", () => {count += 1;});
+        s.subscribe("path1.A.some_data", () => {count += 1;});
 
         a.set('some_data', 0.0);
 
@@ -190,26 +190,26 @@ describe("Subscription", function() {
         s.subscribe("num1", () => {});
         s.subscribe("path1.A.num1", () => {});
         s.subscribe("path1.A.path3.B.num1", () => {});
-        assert.strictEqual(s.subscriptions.length, 3)
-        assert.strictEqual(a.subscriptions.length, 2)
-        assert.strictEqual(b.subscriptions.length, 1)
+        assert.strictEqual(s.subscriptions.length, 3);
+        assert.strictEqual(a.subscriptions.length, 2);
+        assert.strictEqual(b.subscriptions.length, 1);
         done();
-    }); 
+    });
 
     it("Unsubscribing paths removes all paths", (done)=>{
 
         var count = 0;
         // Create two subscriptions
-        s.subscribe("some_data", () => {count += 1});
-        s.subscribe("some_data", () => {count += 1});
+        s.subscribe("some_data", () => {count += 1;});
+        s.subscribe("some_data", () => {count += 1;});
 
-        s.unsubscribe("some_data")
+        s.unsubscribe("some_data");
 
         s.set('some_data', 0.0);
 
         assert.strictEqual(count, 0);
 
-        done()
+        done();
     });
 
 
@@ -217,10 +217,10 @@ describe("Subscription", function() {
 
         var count = 0;
         // Create two subscriptions
-        let uuid1 = s.subscribe("some_data", () => {count += 1});
-        let uuid2 = s.subscribe("some_data", () => {count += 1});
+        let uuid1 = s.subscribe("some_data", () => {count += 1;});
+        let uuid2 = s.subscribe("some_data", () => {count += 1;});
 
-        s.unsubscribe(uuid1)
+        s.unsubscribe(uuid1);
 
         s.set('some_data', 0.0);
 
@@ -228,28 +228,28 @@ describe("Subscription", function() {
         assert.strictEqual(s._subscriptions.length, 1);
         assert.strictEqual(s._subscriptions[0].uuid, uuid2);
 
-        done()
+        done();
     });
 
     it("Pairs of remote stores can subscribe to the same data", (done)=>{
 
         var count = 0;
-        s.subscribe("path2.B.some_data", () => {count += 1});
-        a.subscribe("path3.B.some_data", () => {count += 1})
+        s.subscribe("path2.B.some_data", () => {count += 1;});
+        a.subscribe("path3.B.some_data", () => {count += 1;});
 
         b.set("some_data",0.0);
 
         assert.strictEqual(count, 2);
 
-        done()
+        done();
     });
 
 
     it("Pairs of remote stores don't unsubscribe each other", (done)=>{
 
         var count = 0;
-        let uuid1 = s.subscribe("path2.B.some_data", () => {count += 1});
-        let uuid2 = a.subscribe("path3.B.some_data", () => {count += 1})
+        s.subscribe("path2.B.some_data", () => {count += 1;});
+        let uuid2 = a.subscribe("path3.B.some_data", () => {count += 1;});
 
         s.unsubscribe("path2.B.some_data");
 
@@ -259,7 +259,7 @@ describe("Subscription", function() {
         assert.strictEqual(b._subscriptions.length, 1);
         assert.strictEqual(b._subscriptions[0].uuid, uuid2);
 
-        done()
+        done();
     });
 
     it("Orphaned remote subscriptions are successfully cleaned up", (done) => {
@@ -270,11 +270,11 @@ describe("Subscription", function() {
 
         s.transmit((msg, store)=> {
             if (msg.type==="unsubscribe") number_of_cancels_sent += 1;
-            store.receive(msg, s)
+            store.receive(msg, s);
         });
         a.transmit((msg, store)=> {
             if (msg.type==="event") number_of_events += 1;
-            store.receive(msg, a)
+            store.receive(msg, a);
         });
 
 
@@ -283,32 +283,32 @@ describe("Subscription", function() {
         // orphan the pass through subscription object in A
         s._subscriptions = [];
 
-        a.set("some_data",0.0)
+        a.set("some_data",0.0);
 
         // The cancel message was sent from S to A
-        assert.strictEqual(number_of_cancels_sent,1)
-        assert.strictEqual(number_of_events,1)
+        assert.strictEqual(number_of_cancels_sent,1);
+        assert.strictEqual(number_of_events,1);
 
-        a.set("some_data",0.0)
+        a.set("some_data",0.0);
 
         // A didn't sent the next next event
-        assert.strictEqual(number_of_events,1)
+        assert.strictEqual(number_of_events,1);
 
         done();
-    })
+    });
 
     it("Local sets only triggers a single subscribed callback when multiple subscriptions co-exist", (done)=>{
 
         // Subscribe once to a local endpoint
         var sub_1_triggers = 0;
-        s.subscribe("some_data",(path, val)=>{
+        s.subscribe("some_data",()=>{
             sub_1_triggers += 1;
             assert.strictEqual(sub_1_triggers, 1);
         });
 
         // Subscribe again to the same local endpoint
         var sub_2_triggers = 0;
-        s.subscribe("some_data",(path, val)=>{
+        s.subscribe("some_data",()=>{
             sub_2_triggers += 1;
             assert.strictEqual(sub_2_triggers, 1);
         });
@@ -322,14 +322,14 @@ describe("Subscription", function() {
 
         // Subscribe once to a remote endpoint
         var sub_1_triggers = 0;
-        s.subscribe("path1.A.some_data",(path, val)=>{
+        s.subscribe("path1.A.some_data",()=>{
             sub_1_triggers += 1;
             assert.strictEqual(sub_1_triggers, 1);
         });
 
         // Subscribe again to the same remote endpoint
         var sub_2_triggers = 0;
-        s.subscribe("path1.A.some_data",(path, val)=>{
+        s.subscribe("path1.A.some_data",()=>{
             sub_2_triggers += 1;
             assert.strictEqual(sub_2_triggers, 1);
         });