2.0.4

.gitlab-ci.yml

@@ -12,6 +12,9 @@ stages:
   - release
   - metadata
 
+before_script:
+  - npm install -g @shipzone/npmci
+
 # ====================
 # security stage
 # ====================
@@ -36,6 +39,7 @@ auditProductionDependencies:
     - npmci command npm audit --audit-level=high --only=prod --production
   tags:
     - docker
+  allow_failure: true
 
 auditDevDependencies:
   image: registry.gitlab.com/hosttoday/ht-docker-node:npmci

.snyk

@@ -1,13 +0,0 @@
-# Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
-version: v1.13.5
-# ignores vulnerabilities until expiry date; change duration by modifying expiry date
-ignore:
-  SNYK-JS-JSYAML-173999:
-    - '@pushrocks/smartexpress > @pushrocks/smartfile > js-yaml':
-        reason: None given
-        expires: '2019-05-24T15:16:11.291Z'
-  SNYK-JS-JSYAML-174129:
-    - '@pushrocks/smartexpress > @pushrocks/smartfile > js-yaml':
-        reason: None given
-        expires: '2019-05-24T15:16:11.291Z'
-patch: {}

.vscode/launch.json

@@ -2,28 +2,10 @@
   "version": "0.2.0",
   "configurations": [
     {
-      "name": "current file",
+      "command": "npm test",
-      "type": "node",
+      "name": "Run npm test",
       "request": "launch",
-      "args": [
+      "type": "node-terminal"
-        "${relativeFile}"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
-    },
-    {
-      "name": "test.ts",
-      "type": "node",
-      "request": "launch",
-      "args": [
-        "test/test.ts"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
     }
   ]
 }

.vscode/settings.json

@@ -22,5 +22,6 @@
         }
       }
     }
-  ]
+  ],
+  "typescript.tsdk": "node_modules/typescript/lib"
 }

npmextra.json

@@ -5,7 +5,7 @@
       "githost": "gitlab.com",
       "gitscope": "pushrocks",
       "gitrepo": "smartsocket",
-      "shortDescription": "easy and secure websocket communication",
+      "description": "easy and secure websocket communication",
       "npmPackagename": "@pushrocks/smartsocket",
       "license": "MIT",
       "projectDomain": "push.rocks"

package.json

@@ -1,12 +1,13 @@
 {
   "name": "@pushrocks/smartsocket",
-  "version": "1.1.65",
+  "version": "2.0.4",
   "description": "easy and secure websocket communication",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
+  "type": "module",
   "scripts": {
     "test": "(tstest test/)",
-    "build": "(tsbuild --web && tsbundle --from ./ts/index.ts --to dist_bundle/bundle.js)"
+    "build": "(tsbuild --web --allowimplicitany --skiplibcheck && tsbundle --from ./ts/index.ts --to dist_bundle/bundle.js)"
   },
   "repository": {
     "type": "git",
@@ -20,27 +21,26 @@
   "homepage": "https://gitlab.com/pushrocks/smartsocket#README",
   "dependencies": {
     "@apiglobal/typedrequest-interfaces": "^1.0.15",
-    "@pushrocks/isohash": "^1.0.2",
+    "@pushrocks/isohash": "^2.0.0",
-    "@pushrocks/isounique": "^1.0.4",
+    "@pushrocks/isounique": "^1.0.5",
-    "@pushrocks/lik": "^4.0.17",
+    "@pushrocks/lik": "^5.0.4",
-    "@pushrocks/smartdelay": "^2.0.10",
+    "@pushrocks/smartdelay": "^2.0.13",
-    "@pushrocks/smartenv": "^4.0.15",
+    "@pushrocks/smartenv": "^5.0.0",
-    "@pushrocks/smartexpress": "^3.0.76",
+    "@pushrocks/smartexpress": "^4.0.0",
-    "@pushrocks/smartlog": "^2.0.39",
+    "@pushrocks/smartjson": "^4.0.6",
-    "@pushrocks/smartpromise": "^3.0.6",
+    "@pushrocks/smartlog": "^2.0.44",
-    "@pushrocks/smartrx": "^2.0.19",
+    "@pushrocks/smartpromise": "^3.1.7",
-    "@pushrocks/smarttime": "^3.0.35",
+    "@pushrocks/smartrx": "^2.0.25",
-    "@types/socket.io": "^2.1.11",
+    "@pushrocks/smarttime": "^3.0.45",
-    "@types/socket.io-client": "^1.4.33",
+    "socket.io": "^4.4.1",
-    "socket.io": "^2.3.0",
+    "socket.io-client": "^4.4.1"
-    "socket.io-client": "^2.3.0"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.25",
+    "@gitzone/tsbuild": "^2.1.61",
-    "@gitzone/tsrun": "^1.2.12",
+    "@gitzone/tsrun": "^1.2.32",
-    "@gitzone/tstest": "^1.0.48",
+    "@gitzone/tstest": "^1.0.69",
-    "@pushrocks/tapbundle": "^3.2.9",
+    "@pushrocks/tapbundle": "^5.0.3",
-    "@types/node": "^14.11.2",
+    "@types/node": "^17.0.23",
     "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0"
   },

readme.md

@@ -0,0 +1,122 @@
+# @pushrocks/smartsocket
+easy and secure websocket communication
+
+## Availabililty and Links
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartsocket)
+* [gitlab.com (source)](https://gitlab.com/pushrocks/smartsocket)
+* [github.com (source mirror)](https://github.com/pushrocks/smartsocket)
+* [docs (typedoc)](https://pushrocks.gitlab.io/smartsocket/)
+
+## Status for master
+
+Status Category | Status Badge
+-- | --
+GitLab Pipelines | [![pipeline status](https://gitlab.com/pushrocks/smartsocket/badges/master/pipeline.svg)](https://lossless.cloud)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/pushrocks/smartsocket/badges/master/coverage.svg)](https://lossless.cloud)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@pushrocks/smartsocket)](https://lossless.cloud)
+Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/pushrocks/smartsocket)](https://lossless.cloud)
+TypeScript Support | [![TypeScript](https://badgen.net/badge/TypeScript/>=%203.x/blue?icon=typescript)](https://lossless.cloud)
+node Support | [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](https://lossless.cloud)
+PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@pushrocks/smartsocket)](https://lossless.cloud)
+PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@pushrocks/smartsocket)](https://lossless.cloud)
+BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@pushrocks/smartsocket)](https://lossless.cloud)
+Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20Windows%2010/yes/green?icon=windows)](https://lossless.cloud) [![Supports Mac OS X](https://badgen.net/badge/supports%20Mac%20OS%20X/yes/green?icon=apple)](https://lossless.cloud)
+
+## Usage
+
+Use TypeScript for best in class instellisense.
+
+Under the hood we use socket.io and shortid for managed data exchange.
+
+### Serverside
+
+```typescript
+import * as smartsocket from 'smartsocket';
+import * as q from q; // q is a promise library
+
+// The "Smartsocket" listens on a port and can receive new "SocketConnection" requests.
+let mySmartsocket = new smartsocket.Smartsocket({
+  port: 3000, // the port smartsocket will listen on
+});
+
+// optional:
+// run this with anothoer existing server like express
+declare var someExpressServer; // read the express docs about how express actually works
+mySmartsocket.setServer(someExpressServer);
+
+// A "SocketRole" can be referenced by "SocketFunction"s.
+// All "SocketRequest"s carry authentication data for a specific "SocketRole".
+// "SocketFunction"s know which "SocketRole"s are allowed to execute them
+let mySocketRole = new smartsocket.SocketRole({
+  name: 'someRoleName',
+  passwordHash: 'someHashedString',
+});
+
+// A "SocketFunction" executes a referenced function and passes in any data of the corresponding "SocketRequest".
+// The referenced function must return a promise and resolve with data of type any.
+// Any "SocketRequest" carries a unique identifier. If the referenced function's promise resolved any passed on argument will be returned to the requesting party
+let testSocketFunction1 = new smartsocket.SocketFunction({
+  funcName: 'testSocketFunction1',
+  funcDef: (data) => {
+    console.log('testSocketFunction1 executed successfully!');
+  },
+  allowedRoles: [mySocketRole], // all roles that have access to a specific function
+});
+
+// A "Smartsocket" exposes a .clientCall() that gets
+// 1. the name of the "SocketFunction" on the client side
+// 2. the data to pass in
+// 3. And a target "SocketConnection" (there can be multiple connections at once)
+// any unique id association is done internally
+mySmartsocket.clientCall('restart', data, someTargetConnection).then((responseData) => {});
+```
+
+#### Client side
+
+```typescript
+import * as smartsocket from 'smartsocket';
+
+// A "SmartsocketClient" is different from a "Smartsocket" in that it doesn't expose any public address.
+// Thus any new "SocketConnection"s must be innitiated from a "SmartsocketClient".
+let testSmartsocketClient = new smartsocket.SmartsocketClient({
+  port: testConfig.port,
+  url: 'http://localhost',
+  password: 'testPassword',
+  alias: 'testClient1',
+  role: 'testRole1',
+});
+
+// You can .connect() and .disconnect() from a "Smartsocket"
+testSmartsocketClient.connect().then(() => {
+  done();
+});
+
+// The client can also specify "SocketFunction"s. It can also specify "SocketRole"s in case a client connects to multiple servers at once
+let testSocketFunction2 = new smartsocket.SocketFunction({
+  funcName: 'testSocketFunction2',
+  funcDef: (data) => {}, // the function to execute, has to return promise
+  allowedRoles: [],
+});
+
+// A "SmartsocketClient" can call functions on the serverside using .serverCall() analog to the "Smartsocket"'s .clientCall method.
+mySmartsocketClient.serverCall('function', functionCallData).then((functionResponseData) => {
+  // the functionResponseData comes from the server... awesome, right?
+});
+```
+
+> **NOTE:**  
+> you can easily chain dependent requests on either the server or client side with promises.  
+> `data` is always a js object that you can design for your specific needs.  
+> It supports buffers for large binary data network exchange.
+
+## Contribution
+
+We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
+
+For further information read the linked docs at the top of this readme.
+
+> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+
+[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)

test/common/test.ts

@@ -1 +0,0 @@
-console.log('TODO');

test/test.expressserver.ts

@@ -1,16 +1,13 @@
 // tslint:disable-next-line:no-implicit-dependencies
-import { expect, tap } from '@pushrocks/tapbundle';
+import { expect, expectAsync, tap } from '@pushrocks/tapbundle';
 
-import * as smarthash from '@pushrocks/smarthash';
+import * as isohash from '@pushrocks/isohash';
-import * as smartpromise from '@pushrocks/smartpromise';
 import * as smartexpress from '@pushrocks/smartexpress';
 
-import socketIoClient = require('socket.io-client');
+import * as smartsocket from '../ts/index.js';
-import smartsocket = require('../ts/index');
 
 let testSmartsocket: smartsocket.Smartsocket;
 let testSmartsocketClient: smartsocket.SmartsocketClient;
-let testSocketRole1: smartsocket.SocketRole;
 let testSocketFunction1: smartsocket.SocketFunction<any>;
 let myseServer: smartexpress.Server;
 
@@ -20,8 +17,8 @@ const testConfig = {
 
 // class smartsocket
 tap.test('should create a new smartsocket', async () => {
-  testSmartsocket = new smartsocket.Smartsocket({ port: testConfig.port });
+  testSmartsocket = new smartsocket.Smartsocket({ alias: 'testserver', port: testConfig.port });
-  expect(testSmartsocket).be.instanceOf(smartsocket.Smartsocket);
+  expect(testSmartsocket).toBeInstanceOf(smartsocket.Smartsocket);
 });
 
 tap.test('Should accept an smartExpressServer as server', async () => {
@@ -36,19 +33,10 @@ tap.test('Should accept an smartExpressServer as server', async () => {
   await myseServer.start();
 });
 
-// class socketrole
-tap.test('should add a socketrole', async () => {
-  testSocketRole1 = new smartsocket.SocketRole({
-    name: 'testRole1',
-    passwordHash: smarthash.sha256FromStringSync('testPassword'),
-  });
-  testSmartsocket.addSocketRoles([testSocketRole1]);
-});
 
 // class SocketFunction
 tap.test('should register a new Function', async () => {
   testSocketFunction1 = new smartsocket.SocketFunction({
-    allowedRoles: [testSocketRole1],
     funcDef: async (dataArg, socketConnectionArg) => {
       return dataArg;
     },
@@ -67,12 +55,9 @@ tap.test('should react to a new websocket connection from client', async () => {
   testSmartsocketClient = new smartsocket.SmartsocketClient({
     port: testConfig.port,
     url: 'http://localhost',
-    password: 'testPassword',
     alias: 'testClient1',
-    role: 'testRole1',
   });
   testSmartsocketClient.addSocketFunction(testSocketFunction1);
-  console.log(testSmartsocketClient.socketFunctions);
   await testSmartsocketClient.connect();
 });
 
@@ -87,10 +72,25 @@ tap.test('2 clients should connect in parallel', async () => {
 });
 
 tap.test('should be able to make a functionCall from client to server', async () => {
-  const response = await testSmartsocketClient.serverCall('testFunction1', {
+  const totalCycles = 20000;
-    value1: 'hello',
+  let counter = 0;
-  });
+  let startTime = Date.now();
-  console.log(response);
+  while (counter < totalCycles) {
+    const randomString = `hello ${Math.random()}`;
+    const response: any = await testSmartsocketClient.serverCall('testFunction1', {
+      value1: randomString,
+    });
+    expect(response.value1).toEqual(randomString);
+    if (counter % 100 === 0) {
+      console.log(
+        `processed 100 more messages in ${Date.now() - startTime}ms. ${
+          totalCycles - counter
+        } messages to go.`
+      );
+      startTime = Date.now();
+    }
+    counter++;
+  }
 });
 
 tap.test('should be able to make a functionCall from server to client', async () => {});

test/test.reconnect.ts

@@ -0,0 +1,152 @@
+// tslint:disable-next-line:no-implicit-dependencies
+import { expect, tap } from '@pushrocks/tapbundle';
+
+import * as smartsocket from '../ts/index.js';
+
+let testSmartsocket: smartsocket.Smartsocket;
+let testSmartsocketClient: smartsocket.SmartsocketClient;
+let testSocketFunctionForServer: smartsocket.SocketFunction<any>;
+let testSocketFunctionClient: smartsocket.SocketFunction<any>;
+
+export interface IReqResClient {
+  method: 'testFunction1';
+  request: {
+    value1: string;
+  };
+  response: {
+    value1: string;
+  };
+}
+
+export interface IReqResServer {
+  method: 'testFunction2';
+  request: {
+    hi: string;
+  };
+  response: {
+    hi: string;
+  };
+}
+
+const testConfig = {
+  port: 3000,
+};
+
+// class smartsocket
+tap.test('should create a new smartsocket', async () => {
+  testSmartsocket = new smartsocket.Smartsocket({ alias: 'testserver1', port: testConfig.port });
+  await testSmartsocket.start();
+});
+
+// class SocketFunction
+tap.test('should register a new Function', async () => {
+  testSocketFunctionForServer = new smartsocket.SocketFunction({
+    funcDef: async (dataArg, socketConnectionArg) => {
+      return dataArg;
+    },
+    funcName: 'testFunction1',
+  });
+  testSmartsocket.addSocketFunction(testSocketFunctionForServer);
+
+  testSocketFunctionClient = new smartsocket.SocketFunction({
+    funcDef: async (dataArg, socketConnectionArg) => {
+      return dataArg;
+    },
+    funcName: 'testFunction2',
+  });
+  testSmartsocket.addSocketFunction(testSocketFunctionForServer);
+});
+
+// class SmartsocketClient
+tap.test('should react to a new websocket connection from client', async () => {
+  testSmartsocketClient = new smartsocket.SmartsocketClient({
+    port: testConfig.port,
+    url: 'http://localhost',
+    alias: 'testClient1',
+    autoReconnect: true,
+  });
+  testSmartsocketClient.addSocketFunction(testSocketFunctionClient);
+  await testSmartsocketClient.connect();
+});
+
+tap.test('should be able to tag a connection from client', async (tools) => {
+  await testSmartsocketClient.addTag({
+    id: 'awesome',
+    payload: 'yes',
+  });
+  const tagOnServerSide = await testSmartsocket.socketConnections
+    .findSync((socketConnection) => {
+      return true;
+    })
+    .getTagById('awesome');
+  expect(tagOnServerSide.payload).toEqual('yes');
+});
+
+tap.test('should be able to tag a connection from server', async (tools) => {
+  await testSmartsocket.socketConnections
+    .findSync((socketConnection) => {
+      return true;
+    })
+    .addTag({
+      id: 'awesome2',
+      payload: 'absolutely',
+    });
+  const tagOnClientSide = await testSmartsocketClient.socketConnection.getTagById('awesome2');
+  expect(tagOnClientSide.payload).toEqual('absolutely');
+});
+
+tap.test('should be able to make a functionCall from client to server', async () => {
+  const response = await testSmartsocketClient.serverCall<IReqResClient>('testFunction1', {
+    value1: 'hello',
+  });
+  console.log(response);
+  expect(response.value1).toEqual('hello');
+});
+
+tap.test('should be able to make a functionCall from server to client', async () => {
+  const response = await testSmartsocket.clientCall<IReqResServer>(
+    'testFunction2',
+    {
+      hi: 'hi there from server',
+    },
+    testSmartsocket.socketConnections.findSync((socketConnection) => {
+      return true;
+    })
+  );
+  console.log(response);
+  expect(response.hi).toEqual('hi there from server');
+});
+
+tap.test('client should disconnect and reconnect', async (toolsArg) => {
+  await testSmartsocketClient.disconnect();
+  await testSmartsocketClient.connect();
+  await toolsArg.delayFor(2000);
+  expect(testSmartsocket.socketConnections.getArray().length).toEqual(1);
+});
+
+// class smartsocket
+tap.test('should be able to switch to a new server', async (toolsArg) => {
+  await testSmartsocket.stop();
+  testSmartsocket = new smartsocket.Smartsocket({ alias: 'testserver2', port: testConfig.port });
+  await testSmartsocket.start();
+  await toolsArg.delayFor(30000);
+});
+
+tap.test('should be able to locate a connection tag after reconnect', async (tools) => {
+  expect(testSmartsocket.socketConnections.getArray().length).toEqual(1);
+  const tagOnServerSide = await testSmartsocket.socketConnections
+    .findSync((socketConnection) => {
+      return true;
+    })
+    .getTagById('awesome');
+  expect(tagOnServerSide.payload).toEqual('yes');
+});
+
+// terminate
+tap.test('should close the server', async (tools) => {
+  await testSmartsocketClient.stop();
+  await testSmartsocket.stop();
+  tools.delayFor(1000).then(() => process.exit(0));
+});
+
+tap.start();

test/test.tagging.ts

@@ -1,16 +1,10 @@
 // tslint:disable-next-line:no-implicit-dependencies
 import { expect, tap } from '@pushrocks/tapbundle';
 
-import * as smarthash from '@pushrocks/smarthash';
+import * as smartsocket from '../ts/index.js';
-import * as smartpromise from '@pushrocks/smartpromise';
-
-import socketIoClient = require('socket.io-client');
-import smartsocket = require('../ts/index');
 
 let testSmartsocket: smartsocket.Smartsocket;
 let testSmartsocketClient: smartsocket.SmartsocketClient;
-let testSocketConnection: smartsocket.SocketConnection;
-let testSocketRole1: smartsocket.SocketRole;
 let testSocketFunctionForServer: smartsocket.SocketFunction<any>;
 let testSocketFunctionClient: smartsocket.SocketFunction<any>;
 
@@ -40,23 +34,13 @@ const testConfig = {
 
 // class smartsocket
 tap.test('should create a new smartsocket', async () => {
-  testSmartsocket = new smartsocket.Smartsocket({ port: testConfig.port });
+  testSmartsocket = new smartsocket.Smartsocket({ alias: 'testserver2', port: testConfig.port });
-  expect(testSmartsocket).be.instanceOf(smartsocket.Smartsocket);
+  expect(testSmartsocket).toBeInstanceOf(smartsocket.Smartsocket);
-});
-
-// class socketrole
-tap.test('should add a socketrole', async () => {
-  testSocketRole1 = new smartsocket.SocketRole({
-    name: 'testRole1',
-    passwordHash: smarthash.sha256FromStringSync('testPassword'),
-  });
-  testSmartsocket.addSocketRoles([testSocketRole1]);
 });
 
 // class SocketFunction
 tap.test('should register a new Function', async () => {
   testSocketFunctionForServer = new smartsocket.SocketFunction({
-    allowedRoles: [testSocketRole1],
     funcDef: async (dataArg, socketConnectionArg) => {
       return dataArg;
     },
@@ -65,14 +49,12 @@ tap.test('should register a new Function', async () => {
   testSmartsocket.addSocketFunction(testSocketFunctionForServer);
 
   testSocketFunctionClient = new smartsocket.SocketFunction({
-    allowedRoles: [],
     funcDef: async (dataArg, socketConnectionArg) => {
       return dataArg;
     },
     funcName: 'testFunction2',
   });
   testSmartsocket.addSocketFunction(testSocketFunctionForServer);
-  console.log(testSmartsocket.socketFunctions);
 });
 
 tap.test('should start listening when .started is called', async () => {
@@ -84,15 +66,38 @@ tap.test('should react to a new websocket connection from client', async () => {
   testSmartsocketClient = new smartsocket.SmartsocketClient({
     port: testConfig.port,
     url: 'http://localhost',
-    password: 'testPassword',
     alias: 'testClient1',
-    role: 'testRole1',
   });
   testSmartsocketClient.addSocketFunction(testSocketFunctionClient);
-  console.log(testSmartsocketClient.socketFunctions);
   await testSmartsocketClient.connect();
 });
 
+tap.test('should be able to tag a connection from client', async (tools) => {
+  await testSmartsocketClient.addTag({
+    id: 'awesome',
+    payload: 'yes',
+  });
+  const tagOnServerSide = await testSmartsocket.socketConnections
+    .findSync((socketConnection) => {
+      return true;
+    })
+    .getTagById('awesome');
+  expect(tagOnServerSide.payload).toEqual('yes');
+});
+
+tap.test('should be able to tag a connection from server', async (tools) => {
+  await testSmartsocket.socketConnections
+    .findSync((socketConnection) => {
+      return true;
+    })
+    .addTag({
+      id: 'awesome2',
+      payload: 'absolutely',
+    });
+  const tagOnClientSide = await testSmartsocketClient.socketConnection.getTagById('awesome2');
+  expect(tagOnClientSide.payload).toEqual('absolutely');
+});
+
 tap.test('2 clients should connect in parallel', async () => {
   // TODO: implement parallel test
 });
@@ -102,7 +107,7 @@ tap.test('should be able to make a functionCall from client to server', async ()
     value1: 'hello',
   });
   console.log(response);
-  expect(response.value1).to.equal('hello');
+  expect(response.value1).toEqual('hello');
 });
 
 tap.test('should be able to make a functionCall from server to client', async () => {
@@ -111,20 +116,29 @@ tap.test('should be able to make a functionCall from server to client', async ()
     {
       hi: 'hi there from server',
     },
-    testSmartsocket.socketConnections.find((socketConnection) => {
+    testSmartsocket.socketConnections.findSync((socketConnection) => {
       return true;
     })
   );
   console.log(response);
-  expect(response.hi).to.equal('hi there from server');
+  expect(response.hi).toEqual('hi there from server');
 });
 
 tap.test('client should disconnect and reconnect', async (tools) => {
   await testSmartsocketClient.disconnect();
-  await tools.delayFor(100);
   await testSmartsocketClient.connect();
 });
 
+tap.test('should be able to locate a connection tag after reconnect', async (tools) => {
+  console.log(testSmartsocket.socketConnections.getArray().length);
+  const tagOnServerSide = await testSmartsocket.socketConnections
+    .findSync((socketConnection) => {
+      return true;
+    })
+    .getTagById('awesome');
+  expect(tagOnServerSide.payload).toEqual('yes');
+});
+
 // terminate
 tap.test('should close the server', async () => {
   await testSmartsocket.stop();

ts/index.ts

@@ -1,8 +1,7 @@
 // export main classes
-export * from './smartsocket.classes.smartsocket';
+export * from './smartsocket.classes.smartsocket.js';
-export * from './smartsocket.classes.smartsocketclient';
+export * from './smartsocket.classes.smartsocketclient.js';
 
 // export further classes and objects
-export * from './smartsocket.classes.socketfunction';
+export * from './smartsocket.classes.socketfunction.js';
-export * from './smartsocket.classes.socketrole';
+export * from './smartsocket.classes.socketconnection.js';
-export * from './smartsocket.classes.socketconnection';

ts/interfaces/connection.ts

@@ -1,5 +1,5 @@
 export interface IRequestAuthPayload {
-  serverShortId: string;
+  serverAlias: string;
 }
 
 export type TConnectionStatus =
@@ -7,4 +7,5 @@ export type TConnectionStatus =
   | 'connecting'
   | 'connected'
   | 'disconnecting'
-  | 'disconnected';
+  | 'disconnected'
+  | 'timedOut';

ts/interfaces/index.ts

@@ -1 +1,2 @@
-export * from './connection';
+export * from './connection.js';
+export * from './tag.js';

ts/interfaces/tag.ts

@@ -0,0 +1,6 @@
+export interface ITag<T = any> {
+  id: string;
+  payload: T;
+}
+
+export type TTagStore = { [key: string]: ITag };

ts/smartsocket.classes.smartsocket.ts

@@ -1,20 +1,20 @@
-import * as plugins from './smartsocket.plugins';
+import * as plugins from './smartsocket.plugins.js';
-import * as pluginsTyped from './smartsocket.pluginstyped';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';
 
 // classes
-import { SocketConnection } from './smartsocket.classes.socketconnection';
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
 import {
   ISocketFunctionCallDataRequest,
   SocketFunction,
   ISocketFunctionCallDataResponse,
-} from './smartsocket.classes.socketfunction';
+} from './smartsocket.classes.socketfunction.js';
-import { SocketRequest } from './smartsocket.classes.socketrequest';
+import { SocketRequest } from './smartsocket.classes.socketrequest.js';
-import { SocketRole } from './smartsocket.classes.socketrole';
+import { SocketServer } from './smartsocket.classes.socketserver.js';
-import { SocketServer } from './smartsocket.classes.socketserver';
 
-import { logger } from './smartsocket.logging';
+import { logger } from './smartsocket.logging.js';
 
 export interface ISmartsocketConstructorOptions {
+  alias: string;
   port?: number;
 }
 
@@ -22,12 +22,11 @@ export class Smartsocket {
   /**
    * a unique id to detect server restarts
    */
-  public shortId = plugins.isounique.uni();
+  public alias: string;
   public smartenv = new plugins.smartenv.Smartenv();
   public options: ISmartsocketConstructorOptions;
   public io: pluginsTyped.socketIo.Server;
   public socketConnections = new plugins.lik.ObjectMap<SocketConnection>();
-  public socketRoles = new plugins.lik.ObjectMap<SocketRole>();
   public socketFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
   public socketRequests = new plugins.lik.ObjectMap<SocketRequest<any>>();
 
@@ -35,6 +34,7 @@ export class Smartsocket {
 
   constructor(optionsArg: ISmartsocketConstructorOptions) {
     this.options = optionsArg;
+    this.alias = plugins.isounique.uni(this.options.alias);
   }
 
   // tslint:disable-next-line:member-ordering
@@ -46,8 +46,8 @@ export class Smartsocket {
    * starts smartsocket
    */
   public async start() {
-    const socketIoModule = this.smartenv.getSafeNodeModule('socket.io');
+    const socketIoModule = await this.smartenv.getSafeNodeModule('socket.io');
-    this.io = socketIoModule(this.socketServer.getServerForSocketIo());
+    this.io = new socketIoModule.Server(await this.socketServer.getServerForSocketIo());
     await this.socketServer.start();
     this.io.on('connection', (socketArg) => {
       this._handleSocketConnection(socketArg);
@@ -60,8 +60,10 @@ export class Smartsocket {
   public async stop() {
     await plugins.smartdelay.delayFor(1000);
     this.socketConnections.forEach((socketObjectArg: SocketConnection) => {
-      logger.log('info', `disconnect socket with >>alias ${socketObjectArg.alias}`);
+      if (socketObjectArg) {
-      socketObjectArg.socket.disconnect();
+        logger.log('info', `disconnecting socket with >>alias ${socketObjectArg.alias} due to server stop...`);
+        socketObjectArg.disconnect();
+      }
     });
     this.socketConnections.wipe();
     this.io.close();
@@ -94,16 +96,6 @@ export class Smartsocket {
     return result;
   }
 
-  /**
-   * adds socketRoles
-   */
-  public addSocketRoles(socketRolesArray: SocketRole[]): void {
-    for (const socketRole of socketRolesArray) {
-      this.socketRoles.add(socketRole);
-    }
-    return;
-  }
-
   public addSocketFunction(socketFunction: SocketFunction<any>) {
     this.socketFunctions.add(socketFunction);
   }
@@ -115,14 +107,20 @@ export class Smartsocket {
     const socketConnection: SocketConnection = new SocketConnection({
       alias: undefined,
       authenticated: false,
-      role: undefined,
       side: 'server',
       smartsocketHost: this,
       socket: socketArg,
     });
     logger.log('info', 'Socket connected. Trying to authenticate...');
     this.socketConnections.add(socketConnection);
+    const disconnectSubscription = socketConnection.eventSubject.subscribe((eventArg) => {
+      if (eventArg === 'disconnected') {
+        this.socketConnections.remove(socketConnection);
+        disconnectSubscription.unsubscribe();
+      }
+    });
     await socketConnection.authenticate();
     await socketConnection.listenToFunctionRequests();
+    await socketConnection.socket.emit('serverFullyReactive');
   }
 }

ts/smartsocket.classes.smartsocketclient.ts

@@ -1,15 +1,14 @@
-import * as plugins from './smartsocket.plugins';
+import * as plugins from './smartsocket.plugins.js';
-import * as pluginsTyped from './smartsocket.pluginstyped';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';
-import * as interfaces from './interfaces';
+import * as interfaces from './interfaces/index.js';
 
-import { SocketConnection } from './smartsocket.classes.socketconnection';
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
 import {
   ISocketFunctionCallDataRequest,
   SocketFunction,
-} from './smartsocket.classes.socketfunction';
+} from './smartsocket.classes.socketfunction.js';
-import { ISocketRequestDataObject, SocketRequest } from './smartsocket.classes.socketrequest';
+import { ISocketRequestDataObject, SocketRequest } from './smartsocket.classes.socketrequest.js';
-import { SocketRole } from './smartsocket.classes.socketrole';
+import { logger } from './smartsocket.logging.js';
-import { logger } from './smartsocket.logging';
 
 /**
  * interface for class SmartsocketClient
@@ -18,8 +17,6 @@ export interface ISmartsocketClientOptions {
   port: number;
   url: string;
   alias: string; // an alias makes it easier to identify this client in a multo client environment
-  role: string;
-  password: string; // by setting a password access to functions can be limited
   autoReconnect?: boolean;
 }
 
@@ -31,7 +28,6 @@ export class SmartsocketClient {
   public remoteShortId: string = null;
 
   public alias: string;
-  public socketRole: SocketRole;
   public socketConnection: SocketConnection;
   public serverUrl: string;
   public serverPort: number;
@@ -43,22 +39,50 @@ export class SmartsocketClient {
 
   public socketFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
   public socketRequests = new plugins.lik.ObjectMap<SocketRequest<any>>();
-  public socketRoles = new plugins.lik.ObjectMap<SocketRole>();
+
+  // tagStore
+  private tagStore: { [key: string]: interfaces.ITag } = {};
+  private tagStoreSubscription: plugins.smartrx.rxjs.Subscription;
+
+  /**
+   * adds a tag to a connection
+   */
+  public async addTag(tagArg: interfaces.ITag) {
+    if (this.socketConnection) {
+      await this.socketConnection.addTag(tagArg);
+    } else {
+      this.tagStore[tagArg.id] = tagArg;
+    }
+  }
+
+  /**
+   * gets a tag by id
+   * @param tagIdArg
+   */
+  public async getTagById(tagIdArg: interfaces.ITag['id']) {
+    return this.tagStore[tagIdArg];
+  }
+
+  /**
+   * removes a tag from a connection
+   */
+  public async removeTagById(tagIdArg: interfaces.ITag['id']) {
+    if (this.socketConnection) {
+      this.socketConnection.removeTagById(tagIdArg);
+    } else {
+      delete this.tagStore[tagIdArg];
+    }
+  }
 
   constructor(optionsArg: ISmartsocketClientOptions) {
     this.alias = optionsArg.alias;
     this.serverUrl = optionsArg.url;
     this.serverPort = optionsArg.port;
-    this.socketRole = new SocketRole({
-      name: optionsArg.role,
-      passwordHash: optionsArg.password,
-    });
     this.autoReconnect = optionsArg.autoReconnect;
   }
 
   public addSocketFunction(socketFunction: SocketFunction<any>) {
     this.socketFunctions.add(socketFunction);
-    this.socketRole.allowedFunctions.add(socketFunction);
   }
 
   /**
@@ -67,11 +91,11 @@ export class SmartsocketClient {
   public async connect() {
     const done = plugins.smartpromise.defer();
     const smartenvInstance = new plugins.smartenv.Smartenv();
-    const socketIoClient = await smartenvInstance.getEnvAwareModule({
+    const socketIoClient: any = await smartenvInstance.getEnvAwareModule({
       nodeModuleName: 'socket.io-client',
-      webUrlArg: 'https://cdn.jsdelivr.net/npm/socket.io-client@2/dist/socket.io.js',
+      webUrlArg: 'https://cdn.jsdelivr.net/npm/socket.io-client@4/dist/socket.io.js',
       getFunction: () => {
-        return globalThis.io;
+        return (globalThis as any).io;
       },
     });
     logger.log('info', 'trying to connect...');
@@ -79,96 +103,130 @@ export class SmartsocketClient {
     this.socketConnection = new SocketConnection({
       alias: this.alias,
       authenticated: false,
-      role: this.socketRole,
       side: 'client',
       smartsocketHost: this,
-      socket: await socketIoClient.connect(socketUrl, {
+      socket: await socketIoClient
-        multiplex: false,
+        .connect(socketUrl, {
-        reconnectionAttempts: 5,
+          multiplex: false,
-      }),
+          autoConnect: false,
+          reconnectionAttempts: 0,
+          rejectUnauthorized: socketUrl.startsWith('https://localhost') ? false : true,
+        })
+        .open(),
     });
 
     const timer = new plugins.smarttime.Timer(5000);
     timer.start();
     timer.completed.then(() => {
+      this.updateStatus('timedOut');
       logger.log('warn', 'connection to server timed out.');
-      this.disconnect();
+      this.disconnect(true);
     });
 
     // authentication flow
-    this.socketConnection.socket.on(
+    this.socketConnection.socket.on('requestAuth', (dataArg: interfaces.IRequestAuthPayload) => {
-      'requestAuth',
+      timer.reset();
-      (requestAuthPayload: interfaces.IRequestAuthPayload) => {
+      logger.log('info', `server ${dataArg.serverAlias} requested authentication`);
-        timer.reset();
-        logger.log('info', 'server requested authentication');
 
-        // lets register the authenticated event
+      // lets register the authenticated event
-        this.socketConnection.socket.on('authenticated', () => {
+      this.socketConnection.socket.on('authenticated', async () => {
-          this.remoteShortId = requestAuthPayload.serverShortId;
+        this.remoteShortId = dataArg.serverAlias;
-          logger.log('info', 'client is authenticated');
+        logger.log('info', 'client is authenticated');
-          this.socketConnection.authenticated = true;
+        this.socketConnection.authenticated = true;
-          this.socketConnection.listenToFunctionRequests();
+        await this.socketConnection.listenToFunctionRequests();
-          done.resolve();
+      });
-        });
 
-        // lets register the forbidden event
+      this.socketConnection.socket.on('serverFullyReactive', async () => {
-        this.socketConnection.socket.on('forbidden', async () => {
+        // lets take care of retagging
-          logger.log('warn', `disconnecting due to being forbidden to use the ressource`);
+        const oldTagStore = this.tagStore;
-          await this.disconnect();
+        this.tagStoreSubscription?.unsubscribe();
-        });
+        for (const keyArg of Object.keys(this.tagStore)) {
+          this.socketConnection.addTag(this.tagStore[keyArg]);
+        }
+        this.tagStoreSubscription = this.socketConnection.tagStoreObservable.subscribe(
+          (tagStoreArg) => {
+            this.tagStore = tagStoreArg;
+          }
+        );
 
-        // lets provide the actual auth data
+        for (const tag of Object.keys(oldTagStore)) {
-        this.socketConnection.socket.emit('dataAuth', {
+          await this.addTag(oldTagStore[tag]);
-          role: this.socketRole.name,
+        }
-          password: this.socketRole.passwordHash,
+        this.updateStatus('connected');
-          alias: this.alias,
+        done.resolve();
-        });
+      });
-      }
+
-    );
+      // lets register the forbidden event
+      this.socketConnection.socket.on('forbidden', async () => {
+        logger.log('warn', `disconnecting due to being forbidden to use the ressource`);
+        await this.disconnect();
+      });
+
+      // lets provide the actual auth data
+      this.socketConnection.socket.emit('dataAuth', {
+        alias: this.alias,
+      });
+    });
 
     // handle connection
-    this.socketConnection.socket.on('connect', async () => {
+    this.socketConnection.socket.on('connect', async () => {});
-      this.updateStatus('connected');
-    });
 
     // handle disconnection and errors
     this.socketConnection.socket.on('disconnect', async () => {
-      await this.disconnect();
+      await this.disconnect(true);
     });
 
     this.socketConnection.socket.on('reconnect_failed', async () => {
-      await this.disconnect();
+      await this.disconnect(true);
     });
     this.socketConnection.socket.on('connect_error', async () => {
-      await this.disconnect();
+      await this.disconnect(true);
     });
     return done.promise;
   }
 
+  private disconnectRunning = false;
+
   /**
    * disconnect from the server
    */
-  public async disconnect() {
+  public async disconnect(useAutoReconnectSetting = false) {
+    if (this.disconnectRunning) {
+      return;
+    }
+    this.disconnectRunning = true;
+    this.updateStatus('disconnecting');
+    this.tagStoreSubscription?.unsubscribe();
     if (this.socketConnection) {
       await this.socketConnection.disconnect();
       this.socketConnection = undefined;
-      logger.log('ok', 'disconnected!');
+      logger.log('ok', 'disconnected socket!');
+    } else {
+      this.disconnectRunning = false;
+      logger.log('warn', 'tried to disconnect, without a SocketConnection');
+      return;
     }
+
     logger.log('warn', `disconnected from server ${this.remoteShortId}`);
     this.remoteShortId = null;
-    this.updateStatus('disconnected');
 
-    if (this.autoReconnect) {
+    if (this.autoReconnect && useAutoReconnectSetting && this.eventStatus !== 'connecting') {
-      this.tryDebouncedReconnect();
+      this.updateStatus('connecting');
+      console.log('debounced reconnect!');
+      await plugins.smartdelay.delayForRandom(10000, 20000);
+      this.disconnectRunning = false;
+      await this.connect();
+    } else {
+      this.disconnectRunning = false;
     }
   }
 
   /**
-   * try a reconnection
+   * stops the client completely
    */
-  public async tryDebouncedReconnect() {
+  public async stop() {
-    await plugins.smartdelay.delayForRandom(10000, 60000);
+    this.autoReconnect = false;
-    await this.connect();
+    await this.disconnect();
   }
 
   /**

ts/smartsocket.classes.socketconnection.ts

@@ -1,16 +1,15 @@
-import * as plugins from './smartsocket.plugins';
+import * as plugins from './smartsocket.plugins.js';
-import * as interfaces from './interfaces';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';
+import * as interfaces from './interfaces/index.js';
 
 // import classes
-import { Smartsocket } from './smartsocket.classes.smartsocket';
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
-import { SocketFunction } from './smartsocket.classes.socketfunction';
+import { SocketFunction } from './smartsocket.classes.socketfunction.js';
-import { SocketRequest, ISocketRequestDataObject } from './smartsocket.classes.socketrequest';
+import { SocketRequest, ISocketRequestDataObject } from './smartsocket.classes.socketrequest.js';
-import { SocketRole } from './smartsocket.classes.socketrole';
 
 // socket.io
-import * as SocketIO from 'socket.io';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient.js';
-import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
+import { logger } from './smartsocket.logging.js';
-import { logger } from './smartsocket.logging';
 
 // export interfaces
 
@@ -25,19 +24,16 @@ export type TSocketConnectionSide = 'server' | 'client';
 export interface ISocketConnectionConstructorOptions {
   alias: string;
   authenticated: boolean;
-  role: SocketRole;
   side: TSocketConnectionSide;
   smartsocketHost: Smartsocket | SmartsocketClient;
-  socket: SocketIO.Socket | SocketIOClient.Socket;
+  socket: pluginsTyped.socketIo.Socket | pluginsTyped.socketIoClient.Socket;
 }
 
 /**
  * interface for authentication data
  */
 export interface ISocketConnectionAuthenticationObject {
-  role: 'coreflowContainer';
+  alias: string;
-  password: 'somePassword';
-  alias: 'coreflow1';
 }
 
 // export classes
@@ -50,17 +46,19 @@ export class SocketConnection {
   public alias: string;
   public side: TSocketConnectionSide;
   public authenticated: boolean = false;
-  public role: SocketRole;
   public smartsocketRef: Smartsocket | SmartsocketClient;
-  public socket: SocketIO.Socket | SocketIOClient.Socket;
+  public socket: pluginsTyped.socketIo.Socket | pluginsTyped.socketIoClient.Socket;
 
   public eventSubject = new plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>();
   public eventStatus: interfaces.TConnectionStatus = 'new';
 
+  private tagStore: interfaces.TTagStore = {};
+  public tagStoreObservable = new plugins.smartrx.rxjs.Subject<interfaces.TTagStore>();
+  public remoteTagStoreObservable = new plugins.smartrx.rxjs.Subject<interfaces.TTagStore>();
+
   constructor(optionsArg: ISocketConnectionConstructorOptions) {
     this.alias = optionsArg.alias;
     this.authenticated = optionsArg.authenticated;
-    this.role = optionsArg.role;
     this.side = optionsArg.side;
     this.smartsocketRef = optionsArg.smartsocketHost;
     this.socket = optionsArg.socket;
@@ -79,9 +77,49 @@ export class SocketConnection {
       );
       await this.disconnect();
       allSocketConnections.remove(this);
+      this.eventSubject.next('disconnected');
     });
   }
 
+  /**
+   * adds a tag to a connection
+   */
+  public async addTag(tagArg: interfaces.ITag) {
+    const done = plugins.smartpromise.defer();
+    this.tagStore[tagArg.id] = tagArg;
+    this.tagStoreObservable.next(this.tagStore);
+    const remoteSubscription = this.remoteTagStoreObservable.subscribe((remoteTagStore) => {
+      if (!remoteTagStore[tagArg.id]) {
+        return;
+      }
+      const localTagString = plugins.smartjson.stringify(tagArg);
+      const remoteTagString = plugins.smartjson.stringify(remoteTagStore[tagArg.id]);
+      if (localTagString === remoteTagString) {
+        remoteSubscription.unsubscribe();
+        done.resolve();
+      }
+    });
+    this.socket.emit('updateTagStore', this.tagStore);
+    await done.promise;
+  }
+
+  /**
+   * gets a tag by id
+   * @param tagIdArg
+   */
+  public async getTagById(tagIdArg: interfaces.ITag['id']) {
+    return this.tagStore[tagIdArg];
+  }
+
+  /**
+   * removes a tag from a connection
+   */
+  public async removeTagById(tagIdArg: interfaces.ITag['id']) {
+    delete this.tagStore[tagIdArg];
+    this.tagStoreObservable.next(this.tagStore);
+    this.socket.emit('updateTagStore', this.tagStore);
+  }
+
   // authenticating --------------------------
 
   /**
@@ -90,24 +128,23 @@ export class SocketConnection {
   public authenticate() {
     const done = plugins.smartpromise.defer();
     this.socket.on('dataAuth', async (dataArg: ISocketConnectionAuthenticationObject) => {
-      logger.log('info', 'received authentication data. now hashing and comparing...');
+      logger.log('info', 'received authentication data...');
-      this.socket.removeListener('dataAuth', () => {});
+      this.socket.removeAllListeners('dataAuth');
-      if (await SocketRole.checkPasswordForRole(dataArg, this.smartsocketRef)) {
+      if (dataArg.alias) {
         // TODO: authenticate password
         this.alias = dataArg.alias;
         this.authenticated = true;
-        this.role = SocketRole.getSocketRoleByName(this.smartsocketRef, dataArg.role);
         this.socket.emit('authenticated');
-        logger.log('ok', `socket with >>alias ${this.alias} >>role ${this.role} is authenticated!`);
+        logger.log('ok', `socket with >>alias ${this.alias} is authenticated!`);
         done.resolve(this);
       } else {
         this.authenticated = false;
         await this.disconnect();
-        done.reject('not authenticated');
+        done.reject('a socket tried to connect, but could not authenticated.');
       }
     });
     const requestAuthPayload: interfaces.IRequestAuthPayload = {
-      serverShortId: this.smartsocketRef.shortId,
+      serverAlias: this.smartsocketRef.alias,
     };
     this.socket.emit('requestAuth', requestAuthPayload);
     return done.promise;
@@ -124,7 +161,7 @@ export class SocketConnection {
       this.socket.on('function', (dataArg: ISocketRequestDataObject<any>) => {
         // check if requested function is available to the socket's scope
         // logger.log('info', 'function request received');
-        const referencedFunction: SocketFunction<any> = this.role.allowedFunctions.find(
+        const referencedFunction: SocketFunction<any> = this.smartsocketRef.socketFunctions.findSync(
           (socketFunctionArg) => {
             return socketFunctionArg.name === dataArg.funcCallData.funcName;
           }
@@ -143,14 +180,24 @@ export class SocketConnection {
         }
       });
       this.socket.on('functionResponse', (dataArg: ISocketRequestDataObject<any>) => {
-        logger.log('info', `received response for request with id ${dataArg.shortId}`);
+        // logger.log('info', `received response for request with id ${dataArg.shortId}`);
         const targetSocketRequest = SocketRequest.getSocketRequestById(
           this.smartsocketRef,
           dataArg.shortId
         );
         targetSocketRequest.handleResponse(dataArg);
       });
-      logger.log('info', `now listening to function requests for ${this.alias}`);
+
+      this.socket.on('updateTagStore', async (tagStoreArg: interfaces.TTagStore) => {
+        if (!plugins.smartjson.deepEqualObjects(this.tagStore, tagStoreArg)) {
+          this.tagStore = tagStoreArg;
+          this.socket.emit('updateTagStore', this.tagStore);
+          this.tagStoreObservable.next(this.tagStore);
+        }
+        this.remoteTagStoreObservable.next(tagStoreArg);
+      });
+
+      logger.log('info', `now listening to function requests for ${this.alias} on side ${this.side}`);
       done.resolve(this);
     } else {
       const errMessage = 'socket needs to be authenticated first';

ts/smartsocket.classes.socketfunction.ts

@@ -1,10 +1,9 @@
-import * as plugins from './smartsocket.plugins';
+import * as plugins from './smartsocket.plugins.js';
 
 // import classes
-import { SocketRole } from './smartsocket.classes.socketrole';
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
-import { SocketConnection } from './smartsocket.classes.socketconnection';
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
-import { Smartsocket } from './smartsocket.classes.smartsocket';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient.js';
-import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
 
 // export interfaces
 
@@ -16,7 +15,6 @@ export interface ISocketFunctionConstructorOptions<
 > {
   funcName: T['method'];
   funcDef: TFuncDef<T>;
-  allowedRoles: SocketRole[]; // all roles that are allowed to execute a SocketFunction
 }
 
 /**
@@ -58,7 +56,7 @@ export class SocketFunction<T extends plugins.typedrequestInterfaces.ITypedReque
     smartsocketRefArg: Smartsocket | SmartsocketClient,
     functionNameArg: string
   ): SocketFunction<Q> {
-    return smartsocketRefArg.socketFunctions.find((socketFunctionArg) => {
+    return smartsocketRefArg.socketFunctions.findSync((socketFunctionArg) => {
       return socketFunctionArg.name === functionNameArg;
     });
   }
@@ -66,7 +64,6 @@ export class SocketFunction<T extends plugins.typedrequestInterfaces.ITypedReque
   // INSTANCE
   public name: string;
   public funcDef: TFuncDef<T>;
-  public roles: SocketRole[];
 
   /**
    * the constructor for SocketFunction
@@ -74,10 +71,6 @@ export class SocketFunction<T extends plugins.typedrequestInterfaces.ITypedReque
   constructor(optionsArg: ISocketFunctionConstructorOptions<T>) {
     this.name = optionsArg.funcName;
     this.funcDef = optionsArg.funcDef;
-    this.roles = optionsArg.allowedRoles;
-    for (const socketRoleArg of this.roles) {
-      this._notifyRole(socketRoleArg);
-    }
   }
 
   /**
@@ -97,11 +90,4 @@ export class SocketFunction<T extends plugins.typedrequestInterfaces.ITypedReque
       throw new Error("SocketFunction.name does not match the data argument's .name!");
     }
   }
-
-  /**
-   * notifies a role about access to this SocketFunction
-   */
-  private _notifyRole(socketRoleArg: SocketRole) {
-    socketRoleArg.addSocketFunction(this);
-  }
 }

ts/smartsocket.classes.socketrequest.ts

@@ -1,17 +1,17 @@
-import * as plugins from './smartsocket.plugins';
+import * as plugins from './smartsocket.plugins.js';
 
 // import interfaces
 import {
   SocketFunction,
   ISocketFunctionCallDataRequest,
   ISocketFunctionCallDataResponse,
-} from './smartsocket.classes.socketfunction';
+} from './smartsocket.classes.socketfunction.js';
 
 // import classes
-import { SocketConnection } from './smartsocket.classes.socketconnection';
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
-import { logger } from './smartsocket.logging';
+import { logger } from './smartsocket.logging.js';
-import { Smartsocket } from './smartsocket.classes.smartsocket';
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
-import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient.js';
 
 // export interfaces
 export type TSocketRequestStatus = 'new' | 'pending' | 'finished';
@@ -45,7 +45,7 @@ export class SocketRequest<T extends plugins.typedrequestInterfaces.ITypedReques
     smartsocketRef: Smartsocket | SmartsocketClient,
     shortIdArg: string
   ): SocketRequest<any> {
-    return smartsocketRef.socketRequests.find((socketRequestArg) => {
+    return smartsocketRef.socketRequests.findSync((socketRequestArg) => {
       return socketRequestArg.shortid === shortIdArg;
     });
   }
@@ -90,7 +90,7 @@ export class SocketRequest<T extends plugins.typedrequestInterfaces.ITypedReques
    * handles the response that is received by the requesting side
    */
   public async handleResponse(responseDataArg: ISocketRequestDataObject<T>) {
-    logger.log('info', 'handling response!');
+    // logger.log('info', 'handling response!');
     this.done.resolve(responseDataArg.funcCallData);
     this.smartsocketRef.socketRequests.remove(this);
   }
@@ -110,11 +110,11 @@ export class SocketRequest<T extends plugins.typedrequestInterfaces.ITypedReques
       logger.log('error', `There is no SocketFunction defined for ${this.funcCallData.funcName}`);
       return;
     }
-    logger.log('info', `invoking ${targetSocketFunction.name}`);
+    // logger.log('info', `invoking ${targetSocketFunction.name}`);
     targetSocketFunction
       .invoke(this.funcCallData, this.originSocketConnection)
       .then((resultData) => {
-        logger.log('info', 'got resultData. Sending it to requesting party.');
+        // logger.log('info', 'got resultData. Sending it to requesting party.');
         const responseData: ISocketRequestDataObject<T> = {
           funcCallData: resultData,
           shortId: this.shortid,

ts/smartsocket.classes.socketrole.ts

@@ -1,57 +0,0 @@
-import * as plugins from './smartsocket.plugins';
-
-// import classes
-import { SocketFunction } from './smartsocket.classes.socketfunction';
-import { Smartsocket } from './smartsocket.classes.smartsocket';
-import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
-import { ISocketConnectionAuthenticationObject } from './smartsocket.classes.socketconnection';
-
-/**
- * interface for class SocketRole
- */
-export interface ISocketRoleOptions {
-  name: string;
-  passwordHash: string;
-}
-
-/**
- * A socketrole defines access to certain routines.
- */
-export class SocketRole {
-  // STATIC
-  public static getSocketRoleByName(
-    referenceSmartsocket: Smartsocket | SmartsocketClient,
-    socketRoleNameArg: string
-  ): SocketRole {
-    return referenceSmartsocket.socketRoles.find((socketRoleArg) => {
-      return socketRoleArg.name === socketRoleNameArg;
-    });
-  }
-
-  public static async checkPasswordForRole(
-    dataArg: ISocketConnectionAuthenticationObject,
-    referenceSmartsocket: Smartsocket | SmartsocketClient
-  ): Promise<boolean> {
-    const targetPasswordHash = SocketRole.getSocketRoleByName(referenceSmartsocket, dataArg.role)
-      .passwordHash;
-    const computedCompareHash = await plugins.isohash.sha256FromString(dataArg.password);
-    return targetPasswordHash === computedCompareHash;
-  }
-
-  // INSTANCE
-  public name: string;
-  public passwordHash: string;
-  public allowedFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
-  constructor(optionsArg: ISocketRoleOptions) {
-    this.name = optionsArg.name;
-    this.passwordHash = optionsArg.passwordHash;
-  }
-
-  /**
-   * adds the socketfunction to the socketrole
-   * @param socketFunctionArg
-   */
-  public addSocketFunction(socketFunctionArg: SocketFunction<any>) {
-    this.allowedFunctions.add(socketFunctionArg);
-  }
-}

ts/smartsocket.classes.socketserver.ts

@@ -1,9 +1,9 @@
-import * as plugins from './smartsocket.plugins';
+import * as plugins from './smartsocket.plugins.js';
-import * as pluginsTyped from './smartsocket.pluginstyped';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';
 
 // used in case no other server is supplied
-import { Smartsocket } from './smartsocket.classes.smartsocket';
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
-import { logger } from './smartsocket.logging';
+import { logger } from './smartsocket.logging.js';
 
 /**
  * class socketServer
@@ -11,10 +11,13 @@ import { logger } from './smartsocket.logging';
  */
 export class SocketServer {
   private smartsocket: Smartsocket;
+  private httpServerDeferred: plugins.smartpromise.Deferred<any>;
   private httpServer: pluginsTyped.http.Server | pluginsTyped.https.Server;
-  // wether httpServer is standalone
+  
+  /**
+   * wether httpServer is standalone
+   */
   private standaloneServer = false;
-  private expressServer: any;
 
   constructor(smartSocketInstance: Smartsocket) {
     this.smartsocket = smartSocketInstance;
@@ -28,18 +31,23 @@ export class SocketServer {
     serverType: 'smartexpress',
     serverArg: pluginsTyped.smartexpress.Server
   ) {
+    this.httpServerDeferred = plugins.smartpromise.defer();
     await serverArg.startedPromise;
     this.httpServer = serverArg.httpServer;
+    this.httpServerDeferred.resolve();
   }
 
   /**
    * gets the server for socket.io
    */
-  public getServerForSocketIo() {
+  public async getServerForSocketIo() {
+    if (this.httpServerDeferred) {
+      await this.httpServerDeferred.promise;
+    }
     if (this.httpServer) {
       return this.httpServer;
     } else {
-      const httpModule = this.smartsocket.smartenv.getSafeNodeModule('http');
+      const httpModule = await this.smartsocket.smartenv.getSafeNodeModule('http');
       this.httpServer = new httpModule.Server();
       this.standaloneServer = true;
       return this.httpServer;
@@ -78,5 +86,9 @@ export class SocketServer {
   /**
    * closes the server
    */
-  public async stop() {}
+  public async stop() {
+    if (this.httpServer) {
+      this.httpServer.close();
+    }
+  }
 }

ts/smartsocket.classes.socketstats.ts

@@ -1,3 +0,0 @@
-import * as plugins from './smartsocket.plugins';
-
-export class SocketStats {}

ts/smartsocket.logging.ts

@@ -1,3 +1,3 @@
-import * as plugins from './smartsocket.plugins';
+import * as plugins from './smartsocket.plugins.js';
 
 export const logger = new plugins.smartlog.ConsoleLog();

ts/smartsocket.plugins.ts

@@ -8,6 +8,7 @@ import * as isohash from '@pushrocks/isohash';
 import * as isounique from '@pushrocks/isounique';
 import * as lik from '@pushrocks/lik';
 import * as smartenv from '@pushrocks/smartenv';
+import * as smartjson from '@pushrocks/smartjson';
 import * as smartlog from '@pushrocks/smartlog';
 import * as smartdelay from '@pushrocks/smartdelay';
 import * as smartpromise from '@pushrocks/smartpromise';
@@ -19,6 +20,7 @@ export {
   isounique,
   lik,
   smartenv,
+  smartjson,
   smartlog,
   smartdelay,
   smartpromise,

ts/smartsocket.pluginstyped.ts

@@ -1,6 +1,6 @@
 // node native
-import type http from 'http';
+import type * as http from 'http';
-import type https from 'https';
+import type * as https from 'https';
 
 export { http, https };
 
@@ -10,7 +10,14 @@ import type * as smartexpress from '@pushrocks/smartexpress';
 export { smartexpress };
 
 // third party scope
-import type socketIo from 'socket.io';
+import type { Socket as ServerSocket, Server as ServerServer} from 'socket.io';
-import type socketIoClient from 'socket.io-client';
+import type { Socket as ClientSocket, connect as ClientIo } from 'socket.io-client';
 
-export { socketIo, socketIoClient };
+export namespace socketIo {
+  export type Socket = ServerSocket;
+  export type Server = ServerServer;
+}
+export namespace socketIoClient {
+  export type Socket = ClientSocket;
+  export type connect = typeof ClientIo;
+}

tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "module": "ES2020",
+    "moduleResolution": "node12",
+    "esModuleInterop": true
+  }
+}