1.1.65

.gitignore

@@ -1,4 +1,20 @@
-node_modules/
+.nogit/
+
+# artifacts
 coverage/
+public/
 pages/
 
+# installs
+node_modules/
+
+# caches
+.yarn/
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_*/
+
+# custom

.gitlab-ci.yml

@@ -1,16 +1,16 @@
-# gitzone standard
+# gitzone ci_default
-image: hosttoday/ht-docker-node:npmci
+image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
 
 cache:
   paths:
-  - .npmci_cache/
+    - .npmci_cache/
-  key: "$CI_BUILD_STAGE"
+  key: '$CI_BUILD_STAGE'
 
 stages:
-- security
+  - security
-- test
+  - test
-- release
+  - release
-- metadata
+  - metadata
 
 # ====================
 # security stage
@@ -18,102 +18,114 @@ stages:
 mirror:
   stage: security
   script:
-  - npmci git mirror
+    - npmci git mirror
+  only:
+    - tags
   tags:
-  - docker
+    - lossless
-  - notpriv
+    - docker
+    - notpriv
 
-snyk:
+auditProductionDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
   stage: security
   script:
     - npmci npm prepare
-    - npmci command npm install -g snyk
+    - npmci command npm install --production --ignore-scripts
-    - npmci command npm install --ignore-scripts
+    - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command snyk test
+    - npmci command npm audit --audit-level=high --only=prod --production
   tags:
-  - docker
+    - docker
-  - notpriv
+
+auditDevDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  stage: security
+  script:
+    - npmci npm prepare
+    - npmci command npm install --ignore-scripts
+    - npmci command npm config set registry https://registry.npmjs.org
+    - npmci command npm audit --audit-level=high --only=dev
+  tags:
+    - docker
+  allow_failure: true
 
 # ====================
 # test stage
 # ====================
 
-testLTS:
+testStable:
   stage: test
   script:
-  - npmci npm prepare
+    - npmci npm prepare
-  - npmci node install lts
+    - npmci node install stable
-  - npmci npm install
+    - npmci npm install
-  - npmci npm test
+    - npmci npm test
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-  - docker
+    - docker
-  - notpriv
+
-    
+testBuild:
-testSTABLE:
   stage: test
   script:
-  - npmci npm prepare
+    - npmci npm prepare
-  - npmci node install stable
+    - npmci node install stable
-  - npmci npm install
+    - npmci npm install
-  - npmci npm test
+    - npmci command npm run build
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-  - docker
+    - docker
-  - notpriv
 
 release:
   stage: release
   script:
-  - npmci node install stable
+    - npmci node install stable
-  - npmci npm publish
+    - npmci npm publish
   only:
-  - tags
+    - tags
   tags:
-  - docker
+    - lossless
-  - notpriv
+    - docker
+    - notpriv
 
 # ====================
 # metadata stage
 # ====================
 codequality:
   stage: metadata
-  image: docker:stable
   allow_failure: true
-  services:
+  only:
-    - docker:stable-dind
+    - tags
   script:
-    - export SP_VERSION=$(echo "$CI_SERVER_VERSION" | sed 's/^\([0-9]*\)\.\([0-9]*\).*/\1-\2-stable/')
+    - npmci command npm install -g tslint typescript
-    - docker run
+    - npmci npm prepare
-        --env SOURCE_CODE="$PWD"
+    - npmci npm install
-        --volume "$PWD":/code
+    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
-        --volume /var/run/docker.sock:/var/run/docker.sock
-        "registry.gitlab.com/gitlab-org/security-products/codequality:$SP_VERSION" /code
-  artifacts:
-    paths: [codeclimate.json]
   tags:
-  - docker
+    - lossless
-  - priv
+    - docker
+    - priv
 
 trigger:
   stage: metadata
   script:
-  - npmci trigger
+    - npmci trigger
   only:
-  - tags
+    - tags
   tags:
-  - docker
+    - lossless
-  - notpriv
+    - docker
+    - notpriv
 
 pages:
-  image: hosttoday/ht-docker-node:npmci
   stage: metadata
   script:
-    - npmci command npm install -g typedoc typescript
+    - npmci node install lts
+    - npmci command npm install -g @gitzone/tsdoc
     - npmci npm prepare
     - npmci npm install
-    - npmci command typedoc --module "commonjs" --target "ES2016" --out public/ ts/
+    - npmci command tsdoc
   tags:
+    - lossless
     - docker
     - notpriv
   only:
@@ -121,5 +133,5 @@ pages:
   artifacts:
     expire_in: 1 week
     paths:
-    - public
+      - public
   allow_failure: true

.vscode/launch.json

@@ -0,0 +1,29 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "current file",
+      "type": "node",
+      "request": "launch",
+      "args": [
+        "${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

@@ -0,0 +1,26 @@
+{
+  "json.schemas": [
+    {
+      "fileMatch": ["/npmextra.json"],
+      "schema": {
+        "type": "object",
+        "properties": {
+          "npmci": {
+            "type": "object",
+            "description": "settings for npmci"
+          },
+          "gitzone": {
+            "type": "object",
+            "description": "settings for gitzone",
+            "properties": {
+              "projectType": {
+                "type": "string",
+                "enum": ["website", "element", "service", "npm", "wcc"]
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}

README.md

@@ -1,111 +0,0 @@
-# @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
-[![build status](https://gitlab.com/pushrocks/smartsocket/badges/master/build.svg)](https://gitlab.com/pushrocks/smartsocket/commits/master)
-[![coverage report](https://gitlab.com/pushrocks/smartsocket/badges/master/coverage.svg)](https://gitlab.com/pushrocks/smartsocket/commits/master)
-[![npm downloads per month](https://img.shields.io/npm/dm/@pushrocks/smartsocket.svg)](https://www.npmjs.com/package/@pushrocks/smartsocket)
-[![Known Vulnerabilities](https://snyk.io/test/npm/@pushrocks/smartsocket/badge.svg)](https://snyk.io/test/npm/@pushrocks/smartsocket)
-[![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-[![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/)
-
-## 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.
-
-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.html)
-
-[![repo-footer](https://pushrocks.gitlab.io/assets/repo-footer.svg)](https://maintainedby.lossless.com)

npmextra.json

@@ -1,5 +1,6 @@
 {
   "gitzone": {
+    "projectType": "npm",
     "module": {
       "githost": "gitlab.com",
       "gitscope": "pushrocks",

package.json

@@ -1,12 +1,12 @@
 {
   "name": "@pushrocks/smartsocket",
-  "version": "1.1.35",
+  "version": "1.1.65",
   "description": "easy and secure websocket communication",
-  "main": "dist/index.js",
+  "main": "dist_ts/index.js",
-  "typings": "dist/index.d.ts",
+  "typings": "dist_ts/index.d.ts",
   "scripts": {
-    "test": "tstest test/",
+    "test": "(tstest test/)",
-    "build": "tsbuild"
+    "build": "(tsbuild --web && tsbundle --from ./ts/index.ts --to dist_bundle/bundle.js)"
   },
   "repository": {
     "type": "git",
@@ -19,27 +19,45 @@
   },
   "homepage": "https://gitlab.com/pushrocks/smartsocket#README",
   "dependencies": {
-    "@pushrocks/lik": "^3.0.5",
+    "@apiglobal/typedrequest-interfaces": "^1.0.15",
-    "@pushrocks/smartdelay": "^2.0.3",
+    "@pushrocks/isohash": "^1.0.2",
-    "@pushrocks/smartexpress": "^3.0.19",
+    "@pushrocks/isounique": "^1.0.4",
-    "@pushrocks/smarthash": "^2.0.4",
+    "@pushrocks/lik": "^4.0.17",
-    "@pushrocks/smartlog": "^2.0.19",
+    "@pushrocks/smartdelay": "^2.0.10",
-    "@pushrocks/smartpromise": "^3.0.2",
+    "@pushrocks/smartenv": "^4.0.15",
-    "@types/shortid": "0.0.29",
+    "@pushrocks/smartexpress": "^3.0.76",
-    "@types/socket.io": "^2.1.2",
+    "@pushrocks/smartlog": "^2.0.39",
-    "@types/socket.io-client": "^1.4.32",
+    "@pushrocks/smartpromise": "^3.0.6",
-    "shortid": "^2.2.14",
+    "@pushrocks/smartrx": "^2.0.19",
-    "socket.io": "^2.2.0",
+    "@pushrocks/smarttime": "^3.0.35",
-    "socket.io-client": "^2.2.0"
+    "@types/socket.io": "^2.1.11",
+    "@types/socket.io-client": "^1.4.33",
+    "socket.io": "^2.3.0",
+    "socket.io-client": "^2.3.0"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.8",
+    "@gitzone/tsbuild": "^2.1.25",
-    "@gitzone/tsrun": "^1.2.5",
+    "@gitzone/tsrun": "^1.2.12",
-    "@gitzone/tstest": "^1.0.20",
+    "@gitzone/tstest": "^1.0.48",
-    "@pushrocks/tapbundle": "^3.0.9",
+    "@pushrocks/tapbundle": "^3.2.9",
-    "@types/node": "^11.13.7",
+    "@types/node": "^14.11.2",
-    "tslint": "^5.16.0",
+    "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0"
   },
-  "private": false
+  "private": false,
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ]
 }

test/common/test.ts

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

test/test.expressserver.ts

@@ -11,11 +11,11 @@ import smartsocket = require('../ts/index');
 let testSmartsocket: smartsocket.Smartsocket;
 let testSmartsocketClient: smartsocket.SmartsocketClient;
 let testSocketRole1: smartsocket.SocketRole;
-let testSocketFunction1: smartsocket.SocketFunction;
+let testSocketFunction1: smartsocket.SocketFunction<any>;
 let myseServer: smartexpress.Server;
 
 const testConfig = {
-  port: 3000
+  port: 3000,
 };
 
 // class smartsocket
@@ -28,7 +28,7 @@ tap.test('Should accept an smartExpressServer as server', async () => {
   myseServer = new smartexpress.Server({
     cors: true,
     forceSsl: false,
-    port: testConfig.port
+    port: testConfig.port,
   });
 
   testSmartsocket.setExternalServer('smartexpress', myseServer);
@@ -36,15 +36,11 @@ tap.test('Should accept an smartExpressServer as server', async () => {
   await myseServer.start();
 });
 
-tap.test('should start listening when .started is called', async () => {
-  await testSmartsocket.start();
-});
-
 // class socketrole
 tap.test('should add a socketrole', async () => {
   testSocketRole1 = new smartsocket.SocketRole({
     name: 'testRole1',
-    passwordHash: smarthash.sha256FromStringSync('testPassword')
+    passwordHash: smarthash.sha256FromStringSync('testPassword'),
   });
   testSmartsocket.addSocketRoles([testSocketRole1]);
 });
@@ -53,43 +49,37 @@ tap.test('should add a socketrole', async () => {
 tap.test('should register a new Function', async () => {
   testSocketFunction1 = new smartsocket.SocketFunction({
     allowedRoles: [testSocketRole1],
-    funcDef: async dataArg => {
+    funcDef: async (dataArg, socketConnectionArg) => {
       return dataArg;
     },
-    funcName: 'testFunction1'
+    funcName: 'testFunction1',
   });
+  testSmartsocket.addSocketFunction(testSocketFunction1);
+  console.log(testSmartsocket.socketFunctions);
+});
+
+tap.test('should start listening when .started is called', async () => {
+  await testSmartsocket.start();
 });
 
 // class SmartsocketClient
 tap.test('should react to a new websocket connection from client', async () => {
-  const done = smartpromise.defer();
   testSmartsocketClient = new smartsocket.SmartsocketClient({
     port: testConfig.port,
     url: 'http://localhost',
     password: 'testPassword',
     alias: 'testClient1',
-    role: 'testRole1'
+    role: 'testRole1',
   });
-  testSmartsocketClient.connect().then(() => {
+  testSmartsocketClient.addSocketFunction(testSocketFunction1);
-    done.resolve();
+  console.log(testSmartsocketClient.socketFunctions);
-  });
+  await testSmartsocketClient.connect();
-  await done.promise;
 });
-tap.test('client should disconnect and reconnect', async () => {
+
-  let done = smartpromise.defer();
+tap.test('client should disconnect and reconnect', async (tools) => {
-  testSmartsocketClient
+  await testSmartsocketClient.disconnect();
-    .disconnect()
+  await tools.delayFor(100);
-    .then(() => {
+  await testSmartsocketClient.connect();
-      let done = smartpromise.defer();
-      setTimeout(() => {
-        testSmartsocketClient.connect().then(done.resolve);
-      }, 0);
-      return done.promise;
-    })
-    .then(() => {
-      done.resolve();
-    });
-  await done.promise;
 });
 
 tap.test('2 clients should connect in parallel', async () => {
@@ -97,38 +87,13 @@ tap.test('2 clients should connect in parallel', async () => {
 });
 
 tap.test('should be able to make a functionCall from client to server', async () => {
-  let done = smartpromise.defer();
+  const response = await testSmartsocketClient.serverCall('testFunction1', {
-  testSmartsocketClient
+    value1: 'hello',
-    .serverCall('testFunction1', {
+  });
-      value1: 'hello'
+  console.log(response);
-    })
-    .then(dataArg => {
-      console.log(dataArg);
-      done.resolve();
-    });
-  await done.promise;
 });
 
-tap.test('should be able to make a functionCall from server to client', async () => {
+tap.test('should be able to make a functionCall from server to client', async () => {});
-  let done = smartpromise.defer();
-  let targetSocket = (() => {
-    return smartsocket.allSocketConnections.find(socketConnectionArg => {
-      return socketConnectionArg.alias === 'testClient1';
-    });
-  })();
-  testSmartsocket
-    .clientCall(
-      'testFunction1',
-      {
-        value1: 'helloFromServer'
-      },
-      targetSocket
-    )
-    .then(dataArg => {
-      console.log(dataArg);
-      done.resolve();
-    });
-});
 
 // terminate
 tap.test('should close the server', async () => {

test/test.ts

@@ -9,11 +9,33 @@ import smartsocket = require('../ts/index');
 
 let testSmartsocket: smartsocket.Smartsocket;
 let testSmartsocketClient: smartsocket.SmartsocketClient;
+let testSocketConnection: smartsocket.SocketConnection;
 let testSocketRole1: smartsocket.SocketRole;
-let testSocketFunction1: smartsocket.SocketFunction;
+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
+  port: 3000,
 };
 
 // class smartsocket
@@ -22,60 +44,53 @@ tap.test('should create a new smartsocket', async () => {
   expect(testSmartsocket).be.instanceOf(smartsocket.Smartsocket);
 });
 
-tap.test('should start listening when .started is called', async () => {
-  await testSmartsocket.start();
-});
-
 // class socketrole
 tap.test('should add a socketrole', async () => {
   testSocketRole1 = new smartsocket.SocketRole({
     name: 'testRole1',
-    passwordHash: smarthash.sha256FromStringSync('testPassword')
+    passwordHash: smarthash.sha256FromStringSync('testPassword'),
   });
   testSmartsocket.addSocketRoles([testSocketRole1]);
 });
 
 // class SocketFunction
 tap.test('should register a new Function', async () => {
-  testSocketFunction1 = new smartsocket.SocketFunction({
+  testSocketFunctionForServer = new smartsocket.SocketFunction({
     allowedRoles: [testSocketRole1],
-    funcDef: async dataArg => {
+    funcDef: async (dataArg, socketConnectionArg) => {
       return dataArg;
     },
-    funcName: 'testFunction1'
+    funcName: 'testFunction1',
   });
+  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 () => {
+  await testSmartsocket.start();
 });
 
 // class SmartsocketClient
 tap.test('should react to a new websocket connection from client', async () => {
-  const done = smartpromise.defer();
   testSmartsocketClient = new smartsocket.SmartsocketClient({
     port: testConfig.port,
     url: 'http://localhost',
     password: 'testPassword',
     alias: 'testClient1',
-    role: 'testRole1'
+    role: 'testRole1',
   });
-  testSmartsocketClient.connect().then(() => {
+  testSmartsocketClient.addSocketFunction(testSocketFunctionClient);
-    done.resolve();
+  console.log(testSmartsocketClient.socketFunctions);
-  });
+  await testSmartsocketClient.connect();
-  await done.promise;
-});
-tap.test('client should disconnect and reconnect', async () => {
-  let done = smartpromise.defer();
-  testSmartsocketClient
-    .disconnect()
-    .then(() => {
-      let done = smartpromise.defer();
-      setTimeout(() => {
-        testSmartsocketClient.connect().then(done.resolve);
-      }, 0);
-      return done.promise;
-    })
-    .then(() => {
-      done.resolve();
-    });
-  await done.promise;
 });
 
 tap.test('2 clients should connect in parallel', async () => {
@@ -83,37 +98,31 @@ tap.test('2 clients should connect in parallel', async () => {
 });
 
 tap.test('should be able to make a functionCall from client to server', async () => {
-  let done = smartpromise.defer();
+  const response = await testSmartsocketClient.serverCall<IReqResClient>('testFunction1', {
-  testSmartsocketClient
+    value1: 'hello',
-    .serverCall('testFunction1', {
+  });
-      value1: 'hello'
+  console.log(response);
-    })
+  expect(response.value1).to.equal('hello');
-    .then(dataArg => {
-      console.log(dataArg);
-      done.resolve();
-    });
-  await done.promise;
 });
 
 tap.test('should be able to make a functionCall from server to client', async () => {
-  let done = smartpromise.defer();
+  const response = await testSmartsocket.clientCall<IReqResServer>(
-  let targetSocket = (() => {
+    'testFunction2',
-    return smartsocket.allSocketConnections.find(socketConnectionArg => {
+    {
-      return socketConnectionArg.alias === 'testClient1';
+      hi: 'hi there from server',
-    });
+    },
-  })();
+    testSmartsocket.socketConnections.find((socketConnection) => {
-  testSmartsocket
+      return true;
-    .clientCall(
+    })
-      'testFunction1',
+  );
-      {
+  console.log(response);
-        value1: 'helloFromServer'
+  expect(response.hi).to.equal('hi there from server');
-      },
+});
-      targetSocket
+
-    )
+tap.test('client should disconnect and reconnect', async (tools) => {
-    .then(dataArg => {
+  await testSmartsocketClient.disconnect();
-      console.log(dataArg);
+  await tools.delayFor(100);
-      done.resolve();
+  await testSmartsocketClient.connect();
-    });
 });
 
 // terminate

ts/index.ts

@@ -1,5 +1,3 @@
-import * as plugins from './smartsocket.plugins';
-
 // export main classes
 export * from './smartsocket.classes.smartsocket';
 export * from './smartsocket.classes.smartsocketclient';

ts/interfaces/connection.ts

@@ -0,0 +1,10 @@
+export interface IRequestAuthPayload {
+  serverShortId: string;
+}
+
+export type TConnectionStatus =
+  | 'new'
+  | 'connecting'
+  | 'connected'
+  | 'disconnecting'
+  | 'disconnected';

ts/interfaces/index.ts

@@ -0,0 +1 @@
+export * from './connection';

ts/smartsocket.classes.smartsocket.ts

@@ -1,26 +1,35 @@
 import * as plugins from './smartsocket.plugins';
-import * as helpers from './smartsocket.helpers';
+import * as pluginsTyped from './smartsocket.pluginstyped';
 
 // classes
-import { Objectmap } from '@pushrocks/lik';
 import { SocketConnection } from './smartsocket.classes.socketconnection';
-import { ISocketFunctionCall, SocketFunction } from './smartsocket.classes.socketfunction';
+import {
+  ISocketFunctionCallDataRequest,
+  SocketFunction,
+  ISocketFunctionCallDataResponse,
+} from './smartsocket.classes.socketfunction';
 import { SocketRequest } from './smartsocket.classes.socketrequest';
 import { SocketRole } from './smartsocket.classes.socketrole';
 import { SocketServer } from './smartsocket.classes.socketserver';
 
-// socket.io
+import { logger } from './smartsocket.logging';
-import * as SocketIO from 'socket.io';
 
 export interface ISmartsocketConstructorOptions {
   port?: number;
 }
 
 export class Smartsocket {
+  /**
+   * a unique id to detect server restarts
+   */
+  public shortId = plugins.isounique.uni();
+  public smartenv = new plugins.smartenv.Smartenv();
   public options: ISmartsocketConstructorOptions;
-  public io: SocketIO.Server;
+  public io: pluginsTyped.socketIo.Server;
-  public openSockets = new Objectmap<SocketConnection>();
+  public socketConnections = new plugins.lik.ObjectMap<SocketConnection>();
-  public socketRoles = new Objectmap<SocketRole>();
+  public socketRoles = new plugins.lik.ObjectMap<SocketRole>();
+  public socketFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
+  public socketRequests = new plugins.lik.ObjectMap<SocketRequest<any>>();
 
   private socketServer = new SocketServer(this);
 
@@ -37,9 +46,10 @@ export class Smartsocket {
    * starts smartsocket
    */
   public async start() {
-    this.io = plugins.socketIo(this.socketServer.getServerForSocketIo());
+    const socketIoModule = this.smartenv.getSafeNodeModule('socket.io');
+    this.io = socketIoModule(this.socketServer.getServerForSocketIo());
     await this.socketServer.start();
-    this.io.on('connection', socketArg => {
+    this.io.on('connection', (socketArg) => {
       this._handleSocketConnection(socketArg);
     });
   }
@@ -49,14 +59,11 @@ export class Smartsocket {
    */
   public async stop() {
     await plugins.smartdelay.delayFor(1000);
-    this.openSockets.forEach((socketObjectArg: SocketConnection) => {
+    this.socketConnections.forEach((socketObjectArg: SocketConnection) => {
-      plugins.smartlog.defaultLogger.log(
+      logger.log('info', `disconnect socket with >>alias ${socketObjectArg.alias}`);
-        'info',
-        `disconnect socket with >>alias ${socketObjectArg.alias}`
-      );
       socketObjectArg.socket.disconnect();
     });
-    this.openSockets.wipe();
+    this.socketConnections.wipe();
     this.io.close();
 
     // stop the corresponging server
@@ -68,25 +75,22 @@ export class Smartsocket {
   /**
    * allows call to specific client.
    */
-  public async clientCall(
+  public async clientCall<T extends plugins.typedrequestInterfaces.ITypedRequest>(
-    functionNameArg: string,
+    functionNameArg: T['method'],
-    dataArg: any,
+    dataArg: T['request'],
     targetSocketConnectionArg: SocketConnection
-  ) {
+  ): Promise<T['response']> {
-    const done = plugins.smartpromise.defer();
+    const socketRequest = new SocketRequest<T>(this, {
-    const socketRequest = new SocketRequest({
       funcCallData: {
         funcDataArg: dataArg,
-        funcName: functionNameArg
+        funcName: functionNameArg,
       },
       originSocketConnection: targetSocketConnectionArg,
-      shortId: plugins.shortid.generate(),
+      shortId: plugins.isounique.uni(),
-      side: 'requesting'
+      side: 'requesting',
     });
-    socketRequest.dispatch().then((dataArg: ISocketFunctionCall) => {
+    const response: ISocketFunctionCallDataResponse<T> = await socketRequest.dispatch();
-      done.resolve(dataArg.funcDataArg);
+    const result = response.funcDataArg;
-    });
-    const result = await done.promise;
     return result;
   }
 
@@ -100,27 +104,25 @@ export class Smartsocket {
     return;
   }
 
+  public addSocketFunction(socketFunction: SocketFunction<any>) {
+    this.socketFunctions.add(socketFunction);
+  }
+
   /**
    * the standard handler for new socket connections
    */
-  private _handleSocketConnection(socketArg) {
+  private async _handleSocketConnection(socketArg: pluginsTyped.socketIo.Socket) {
     const socketConnection: SocketConnection = new SocketConnection({
       alias: undefined,
       authenticated: false,
       role: undefined,
       side: 'server',
       smartsocketHost: this,
-      socket: socketArg
+      socket: socketArg,
     });
-    plugins.smartlog.defaultLogger.log('info', 'Socket connected. Trying to authenticate...');
+    logger.log('info', 'Socket connected. Trying to authenticate...');
-    this.openSockets.add(socketConnection);
+    this.socketConnections.add(socketConnection);
-    socketConnection
+    await socketConnection.authenticate();
-      .authenticate()
+    await socketConnection.listenToFunctionRequests();
-      .then(() => {
-        return socketConnection.listenToFunctionRequests();
-      })
-      .catch(err => {
-        console.log(err);
-      });
   }
 }

ts/smartsocket.classes.smartsocketclient.ts

@@ -1,8 +1,15 @@
 import * as plugins from './smartsocket.plugins';
+import * as pluginsTyped from './smartsocket.pluginstyped';
+import * as interfaces from './interfaces';
 
 import { SocketConnection } from './smartsocket.classes.socketconnection';
-import { ISocketFunctionCall, SocketFunction } from './smartsocket.classes.socketfunction';
+import {
+  ISocketFunctionCallDataRequest,
+  SocketFunction,
+} from './smartsocket.classes.socketfunction';
 import { ISocketRequestDataObject, SocketRequest } from './smartsocket.classes.socketrequest';
+import { SocketRole } from './smartsocket.classes.socketrole';
+import { logger } from './smartsocket.logging';
 
 /**
  * interface for class SmartsocketClient
@@ -13,78 +20,185 @@ export interface ISmartsocketClientOptions {
   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;
 }
 
 export class SmartsocketClient {
-  alias: string;
+  // a unique id
-  role: string;
+  public shortId = plugins.isounique.uni();
-  socketConnection: SocketConnection;
+
-  serverUrl: string;
+  // the shortId of the remote we connect to
-  serverPort: number;
+  public remoteShortId: string = null;
-  serverPassword: string;
+
+  public alias: string;
+  public socketRole: SocketRole;
+  public socketConnection: SocketConnection;
+  public serverUrl: string;
+  public serverPort: number;
+  public autoReconnect: boolean;
+
+  // status handling
+  public eventSubject = new plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>();
+  public eventStatus: interfaces.TConnectionStatus = 'new';
+
+  public socketFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
+  public socketRequests = new plugins.lik.ObjectMap<SocketRequest<any>>();
+  public socketRoles = new plugins.lik.ObjectMap<SocketRole>();
+
   constructor(optionsArg: ISmartsocketClientOptions) {
     this.alias = optionsArg.alias;
-    this.role = optionsArg.role;
     this.serverUrl = optionsArg.url;
     this.serverPort = optionsArg.port;
-    this.serverPassword = optionsArg.password;
+    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);
   }
 
   /**
    * connect the client to the server
    */
-  connect() {
+  public async connect() {
-    let done = plugins.smartpromise.defer();
+    const done = plugins.smartpromise.defer();
-    plugins.smartlog.defaultLogger.log('info', 'trying to connect...');
+    const smartenvInstance = new plugins.smartenv.Smartenv();
-    let socketUrl = `${this.serverUrl}:${this.serverPort}`;
+    const socketIoClient = await smartenvInstance.getEnvAwareModule({
+      nodeModuleName: 'socket.io-client',
+      webUrlArg: 'https://cdn.jsdelivr.net/npm/socket.io-client@2/dist/socket.io.js',
+      getFunction: () => {
+        return globalThis.io;
+      },
+    });
+    logger.log('info', 'trying to connect...');
+    const socketUrl = `${this.serverUrl}:${this.serverPort}`;
     this.socketConnection = new SocketConnection({
       alias: this.alias,
       authenticated: false,
-      role: undefined,
+      role: this.socketRole,
       side: 'client',
-      smartsocketHost: null,
+      smartsocketHost: this,
-      socket: plugins.socketIoClient(socketUrl, { multiplex: false })
+      socket: await socketIoClient.connect(socketUrl, {
+        multiplex: false,
+        reconnectionAttempts: 5,
+      }),
     });
-    this.socketConnection.socket.on('requestAuth', () => {
+
-      console.log('server requested authentication');
+    const timer = new plugins.smarttime.Timer(5000);
-      this.socketConnection.socket.emit('dataAuth', {
+    timer.start();
-        role: this.role,
+    timer.completed.then(() => {
-        password: this.serverPassword,
+      logger.log('warn', 'connection to server timed out.');
-        alias: this.alias
+      this.disconnect();
-      });
+    });
-      this.socketConnection.socket.on('authenticated', () => {
+
-        console.log('client is authenticated');
+    // authentication flow
-        this.socketConnection.authenticated = true;
+    this.socketConnection.socket.on(
-        this.socketConnection.listenToFunctionRequests();
+      'requestAuth',
-        done.resolve();
+      (requestAuthPayload: interfaces.IRequestAuthPayload) => {
-      });
+        timer.reset();
+        logger.log('info', 'server requested authentication');
+
+        // lets register the authenticated event
+        this.socketConnection.socket.on('authenticated', () => {
+          this.remoteShortId = requestAuthPayload.serverShortId;
+          logger.log('info', 'client is authenticated');
+          this.socketConnection.authenticated = true;
+          this.socketConnection.listenToFunctionRequests();
+          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', {
+          role: this.socketRole.name,
+          password: this.socketRole.passwordHash,
+          alias: this.alias,
+        });
+      }
+    );
+
+    // handle connection
+    this.socketConnection.socket.on('connect', async () => {
+      this.updateStatus('connected');
+    });
+
+    // handle disconnection and errors
+    this.socketConnection.socket.on('disconnect', async () => {
+      await this.disconnect();
+    });
+
+    this.socketConnection.socket.on('reconnect_failed', async () => {
+      await this.disconnect();
+    });
+    this.socketConnection.socket.on('connect_error', async () => {
+      await this.disconnect();
     });
     return done.promise;
   }
 
-  disconnect() {
+  /**
-    let done = plugins.smartpromise.defer();
+   * disconnect from the server
-    this.socketConnection.socket.disconnect();
+   */
-    this.socketConnection = undefined;
+  public async disconnect() {
-    plugins.smartlog.defaultLogger.log('ok', 'disconnected!');
+    if (this.socketConnection) {
-    done.resolve();
+      await this.socketConnection.disconnect();
-    return done.promise;
+      this.socketConnection = undefined;
+      logger.log('ok', 'disconnected!');
+    }
+    logger.log('warn', `disconnected from server ${this.remoteShortId}`);
+    this.remoteShortId = null;
+    this.updateStatus('disconnected');
+
+    if (this.autoReconnect) {
+      this.tryDebouncedReconnect();
+    }
   }
 
-  serverCall(functionNameArg: string, dataArg: any) {
+  /**
-    let done = plugins.smartpromise.defer();
+   * try a reconnection
-    let socketRequest = new SocketRequest({
+   */
+  public async tryDebouncedReconnect() {
+    await plugins.smartdelay.delayForRandom(10000, 60000);
+    await this.connect();
+  }
+
+  /**
+   * dispatches a server call
+   * @param functionNameArg
+   * @param dataArg
+   */
+  public async serverCall<T extends plugins.typedrequestInterfaces.ITypedRequest>(
+    functionNameArg: T['method'],
+    dataArg: T['request']
+  ): Promise<T['response']> {
+    const done = plugins.smartpromise.defer();
+    const socketRequest = new SocketRequest<T>(this, {
       side: 'requesting',
       originSocketConnection: this.socketConnection,
-      shortId: plugins.shortid.generate(),
+      shortId: plugins.isounique.uni(),
       funcCallData: {
         funcName: functionNameArg,
-        funcDataArg: dataArg
+        funcDataArg: dataArg,
-      }
+      },
     });
-    socketRequest.dispatch().then((dataArg: ISocketFunctionCall) => {
+    const response = await socketRequest.dispatch();
-      done.resolve(dataArg.funcDataArg);
+    const result = response.funcDataArg;
-    });
+    return result;
-    return done.promise;
+  }
+
+  private updateStatus(statusArg: interfaces.TConnectionStatus) {
+    if (this.eventStatus !== statusArg) {
+      this.eventSubject.next(statusArg);
+    }
+    this.eventStatus = statusArg;
   }
 }

ts/smartsocket.classes.socketconnection.ts

@@ -1,20 +1,16 @@
 import * as plugins from './smartsocket.plugins';
-import * as helpers from './smartsocket.helpers';
+import * as interfaces from './interfaces';
-
-import { Objectmap } from '@pushrocks/lik';
 
 // import classes
 import { Smartsocket } from './smartsocket.classes.smartsocket';
 import { SocketFunction } from './smartsocket.classes.socketfunction';
-import {
+import { SocketRequest, ISocketRequestDataObject } from './smartsocket.classes.socketrequest';
-  SocketRequest,
-  ISocketRequestDataObject,
-  allSocketRequests
-} from './smartsocket.classes.socketrequest';
 import { SocketRole } from './smartsocket.classes.socketrole';
 
 // socket.io
 import * as SocketIO from 'socket.io';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
+import { logger } from './smartsocket.logging';
 
 // export interfaces
 
@@ -31,7 +27,7 @@ export interface ISocketConnectionConstructorOptions {
   authenticated: boolean;
   role: SocketRole;
   side: TSocketConnectionSide;
-  smartsocketHost: Smartsocket;
+  smartsocketHost: Smartsocket | SmartsocketClient;
   socket: SocketIO.Socket | SocketIOClient.Socket;
 }
 
@@ -45,34 +41,43 @@ export interface ISocketConnectionAuthenticationObject {
 }
 
 // export classes
-export let allSocketConnections = new Objectmap<SocketConnection>();
+export let allSocketConnections = new plugins.lik.ObjectMap<SocketConnection>();
 
 /**
  * class SocketConnection represents a websocket connection
  */
 export class SocketConnection {
-  alias: string;
+  public alias: string;
-  side: TSocketConnectionSide;
+  public side: TSocketConnectionSide;
-  authenticated: boolean = false;
+  public authenticated: boolean = false;
-  role: SocketRole;
+  public role: SocketRole;
-  smartsocketHost: Smartsocket;
+  public smartsocketRef: Smartsocket | SmartsocketClient;
-  socket: any; // SocketIO.Socket | SocketIOClient.Socket
+  public socket: SocketIO.Socket | SocketIOClient.Socket;
+
+  public eventSubject = new plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>();
+  public eventStatus: interfaces.TConnectionStatus = 'new';
+
   constructor(optionsArg: ISocketConnectionConstructorOptions) {
     this.alias = optionsArg.alias;
     this.authenticated = optionsArg.authenticated;
     this.role = optionsArg.role;
     this.side = optionsArg.side;
-    this.smartsocketHost = optionsArg.smartsocketHost;
+    this.smartsocketRef = optionsArg.smartsocketHost;
     this.socket = optionsArg.socket;
 
     // standard behaviour that is always true
     allSocketConnections.add(this);
-    this.socket.on('disconnect', () => {
+
-      plugins.smartlog.defaultLogger.log(
+    // handle connection
+    this.socket.on('connect', async () => {
+      this.updateStatus('connected');
+    });
+    this.socket.on('disconnect', async () => {
+      logger.log(
         'info',
         `SocketConnection with >alias ${this.alias} on >side ${this.side} disconnected`
       );
-      this.socket.disconnect();
+      await this.disconnect();
       allSocketConnections.remove(this);
     });
   }
@@ -82,32 +87,29 @@ export class SocketConnection {
   /**
    * authenticate the socket
    */
-  authenticate() {
+  public authenticate() {
-    let done = plugins.smartpromise.defer();
+    const done = plugins.smartpromise.defer();
-    this.socket.on('dataAuth', (dataArg: ISocketConnectionAuthenticationObject) => {
+    this.socket.on('dataAuth', async (dataArg: ISocketConnectionAuthenticationObject) => {
-      plugins.smartlog.defaultLogger.log(
+      logger.log('info', 'received authentication data. now hashing and comparing...');
-        'info',
-        'received authentication data. now hashing and comparing...'
-      );
       this.socket.removeListener('dataAuth', () => {});
-      if (helpers.checkPasswordForRole(dataArg, this.smartsocketHost)) {
+      if (await SocketRole.checkPasswordForRole(dataArg, this.smartsocketRef)) {
         // TODO: authenticate password
         this.alias = dataArg.alias;
         this.authenticated = true;
-        this.role = helpers.getSocketRoleByName(dataArg.role, this.smartsocketHost);
+        this.role = SocketRole.getSocketRoleByName(this.smartsocketRef, dataArg.role);
         this.socket.emit('authenticated');
-        plugins.smartlog.defaultLogger.log(
+        logger.log('ok', `socket with >>alias ${this.alias} >>role ${this.role} is authenticated!`);
-          'ok',
-          `socket with >>alias ${this.alias} >>role ${this.role} is authenticated!`
-        );
         done.resolve(this);
       } else {
         this.authenticated = false;
-        this.socket.disconnect();
+        await this.disconnect();
         done.reject('not authenticated');
       }
     });
-    this.socket.emit('requestAuth');
+    const requestAuthPayload: interfaces.IRequestAuthPayload = {
+      serverShortId: this.smartsocketRef.shortId,
+    };
+    this.socket.emit('requestAuth', requestAuthPayload);
     return done.promise;
   }
 
@@ -116,53 +118,58 @@ export class SocketConnection {
   /**
    * listen to function requests
    */
-  listenToFunctionRequests() {
+  public listenToFunctionRequests() {
-    let done = plugins.smartpromise.defer();
+    const done = plugins.smartpromise.defer();
     if (this.authenticated) {
-      this.socket.on('function', (dataArg: ISocketRequestDataObject) => {
+      this.socket.on('function', (dataArg: ISocketRequestDataObject<any>) => {
         // check if requested function is available to the socket's scope
-        plugins.smartlog.defaultLogger.log('info', 'function request received');
+        // logger.log('info', 'function request received');
-        let referencedFunction: SocketFunction = this.role.allowedFunctions.find(
+        const referencedFunction: SocketFunction<any> = this.role.allowedFunctions.find(
-          socketFunctionArg => {
+          (socketFunctionArg) => {
             return socketFunctionArg.name === dataArg.funcCallData.funcName;
           }
         );
-        if (referencedFunction !== undefined) {
+        if (referencedFunction) {
-          plugins.smartlog.defaultLogger.log('ok', 'function in access scope');
+          // logger.log('ok', 'function in access scope');
-          let localSocketRequest = new SocketRequest({
+          const localSocketRequest = new SocketRequest(this.smartsocketRef, {
             side: 'responding',
             originSocketConnection: this,
             shortId: dataArg.shortId,
-            funcCallData: dataArg.funcCallData
+            funcCallData: dataArg.funcCallData,
           });
           localSocketRequest.createResponse(); // takes care of creating response and sending it back
         } else {
-          plugins.smartlog.defaultLogger.log(
+          logger.log('warn', 'function not existent or out of access scope');
-            'warn',
-            'function not existent or out of access scope'
-          );
         }
       });
-      this.socket.on('functionResponse', (dataArg: ISocketRequestDataObject) => {
+      this.socket.on('functionResponse', (dataArg: ISocketRequestDataObject<any>) => {
-        plugins.smartlog.defaultLogger.log(
+        logger.log('info', `received response for request with id ${dataArg.shortId}`);
-          'info',
+        const targetSocketRequest = SocketRequest.getSocketRequestById(
-          `received response for request with id ${dataArg.shortId}`
+          this.smartsocketRef,
+          dataArg.shortId
         );
-        let targetSocketRequest = helpers.getSocketRequestById(dataArg.shortId);
         targetSocketRequest.handleResponse(dataArg);
       });
-      plugins.smartlog.defaultLogger.log(
+      logger.log('info', `now listening to function requests for ${this.alias}`);
-        'info',
-        `now listening to function requests for ${this.alias}`
-      );
       done.resolve(this);
     } else {
-      let errMessage: 'socket needs to be authenticated first';
+      const errMessage = 'socket needs to be authenticated first';
-      plugins.smartlog.defaultLogger.log('error', errMessage);
+      logger.log('error', errMessage);
       done.reject(errMessage);
     }
     return done.promise;
   }
 
-  // sending ----------------------
+  // disconnecting ----------------------
+  public async disconnect() {
+    this.socket.disconnect(true);
+    this.updateStatus('disconnected');
+  }
+
+  private updateStatus(statusArg: interfaces.TConnectionStatus) {
+    if (this.eventStatus !== statusArg) {
+      this.eventSubject.next(statusArg);
+    }
+    this.eventStatus = statusArg;
+  }
 }

ts/smartsocket.classes.socketfunction.ts

@@ -1,78 +1,101 @@
 import * as plugins from './smartsocket.plugins';
 
 // import classes
-import { Objectmap } from '@pushrocks/lik';
 import { SocketRole } from './smartsocket.classes.socketrole';
+import { SocketConnection } from './smartsocket.classes.socketconnection';
+import { Smartsocket } from './smartsocket.classes.smartsocket';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
 
 // export interfaces
 
 /**
  * interface of the contructor options of class SocketFunction
  */
-export interface ISocketFunctionConstructorOptions {
+export interface ISocketFunctionConstructorOptions<
-  funcName: string;
+  T extends plugins.typedrequestInterfaces.ITypedRequest
-  funcDef: any;
+> {
+  funcName: T['method'];
+  funcDef: TFuncDef<T>;
   allowedRoles: SocketRole[]; // all roles that are allowed to execute a SocketFunction
 }
 
 /**
  * interface of the Socket Function call, in other words the object that routes a call to a function
  */
-export interface ISocketFunctionCall {
+export interface ISocketFunctionCallDataRequest<
-  funcName: string;
+  T extends plugins.typedrequestInterfaces.ITypedRequest
-  funcDataArg: any;
+> {
+  funcName: T['method'];
+  funcDataArg: T['request'];
+}
+
+/**
+ * interface of the Socket Function call, in other words the object that routes a call to a function
+ */
+export interface ISocketFunctionCallDataResponse<
+  T extends plugins.typedrequestInterfaces.ITypedRequest
+> {
+  funcName: T['method'];
+  funcDataArg: T['response'];
 }
 
 /**
  * interface for function definition of SocketFunction
  */
-export interface IFuncDef {
+export type TFuncDef<T extends plugins.typedrequestInterfaces.ITypedRequest> = (
-  (dataArg: any): PromiseLike<any>;
+  dataArg: T['request'],
-}
+  connectionArg: SocketConnection
-
+) => PromiseLike<T['response']>;
-// export objects
-export let allSocketFunctions = new Objectmap<SocketFunction>();
 
 // export classes
 
 /**
  * class that respresents a function that can be transparently called using a SocketConnection
  */
-export class SocketFunction {
+export class SocketFunction<T extends plugins.typedrequestInterfaces.ITypedRequest> {
-  name: string;
+  // STATIC
-  funcDef: IFuncDef;
+  public static getSocketFunctionByName<Q extends plugins.typedrequestInterfaces.ITypedRequest>(
-  roles: SocketRole[];
+    smartsocketRefArg: Smartsocket | SmartsocketClient,
+    functionNameArg: string
+  ): SocketFunction<Q> {
+    return smartsocketRefArg.socketFunctions.find((socketFunctionArg) => {
+      return socketFunctionArg.name === functionNameArg;
+    });
+  }
+
+  // INSTANCE
+  public name: string;
+  public funcDef: TFuncDef<T>;
+  public roles: SocketRole[];
 
   /**
    * the constructor for SocketFunction
    */
-  constructor(optionsArg: ISocketFunctionConstructorOptions) {
+  constructor(optionsArg: ISocketFunctionConstructorOptions<T>) {
     this.name = optionsArg.funcName;
     this.funcDef = optionsArg.funcDef;
     this.roles = optionsArg.allowedRoles;
-    for (let socketRoleArg of this.roles) {
+    for (const socketRoleArg of this.roles) {
       this._notifyRole(socketRoleArg);
     }
-    allSocketFunctions.add(this); // map instance with Objectmap
   }
 
   /**
    * invokes the function of this SocketFunction
    */
-  invoke(dataArg: ISocketFunctionCall): Promise<any> {
+  public async invoke(
-    let done = plugins.smartpromise.defer();
+    dataArg: ISocketFunctionCallDataRequest<T>,
+    socketConnectionArg: SocketConnection
+  ): Promise<ISocketFunctionCallDataResponse<T>> {
     if (dataArg.funcName === this.name) {
-      this.funcDef(dataArg.funcDataArg).then((resultData: any) => {
+      const funcResponseData: ISocketFunctionCallDataResponse<T> = {
-        let funcResponseData: ISocketFunctionCall = {
+        funcName: this.name,
-          funcName: this.name,
+        funcDataArg: await this.funcDef(dataArg.funcDataArg, socketConnectionArg),
-          funcDataArg: resultData
+      };
-        };
+      return funcResponseData;
-        done.resolve(funcResponseData);
-      });
     } else {
       throw new Error("SocketFunction.name does not match the data argument's .name!");
     }
-    return done.promise;
   }
 
   /**

ts/smartsocket.classes.socketrequest.ts

@@ -1,14 +1,17 @@
 import * as plugins from './smartsocket.plugins';
-import * as helpers from './smartsocket.helpers';
 
 // import interfaces
-import { ISocketFunctionCall } from './smartsocket.classes.socketfunction';
+import {
+  SocketFunction,
+  ISocketFunctionCallDataRequest,
+  ISocketFunctionCallDataResponse,
+} from './smartsocket.classes.socketfunction';
 
 // import classes
-import { Objectmap } from '@pushrocks/lik';
-import { SocketFunction } from './smartsocket.classes.socketfunction';
 import { SocketConnection } from './smartsocket.classes.socketconnection';
-import { defaultLogger } from '@pushrocks/smartlog';
+import { logger } from './smartsocket.logging';
+import { Smartsocket } from './smartsocket.classes.smartsocket';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient';
 
 // export interfaces
 export type TSocketRequestStatus = 'new' | 'pending' | 'finished';
@@ -17,39 +20,56 @@ export type TSocketRequestSide = 'requesting' | 'responding';
 /**
  * interface of constructor of class SocketRequest
  */
-export interface SocketRequestConstructorOptions {
+export interface ISocketRequestConstructorOptions<
+  T extends plugins.typedrequestInterfaces.ITypedRequest
+> {
   side: TSocketRequestSide;
   originSocketConnection: SocketConnection;
   shortId: string;
-  funcCallData?: ISocketFunctionCall;
+  funcCallData?: ISocketFunctionCallDataRequest<T>;
 }
 
 /**
  * request object that is sent initially and may or may not receive a response
  */
-export interface ISocketRequestDataObject {
+export interface ISocketRequestDataObject<T extends plugins.typedrequestInterfaces.ITypedRequest> {
-  funcCallData: ISocketFunctionCall;
+  funcCallData: ISocketFunctionCallDataRequest<T> | ISocketFunctionCallDataResponse<T>;
   shortId: string;
   responseTimeout?: number;
 }
 
-// export objects
-export let allSocketRequests = new Objectmap<SocketRequest>();
-
 // export classes
-export class SocketRequest {
+export class SocketRequest<T extends plugins.typedrequestInterfaces.ITypedRequest> {
-  status: TSocketRequestStatus = 'new';
+  // STATIC
-  side: TSocketRequestSide;
+  public static getSocketRequestById(
-  shortid: string;
+    smartsocketRef: Smartsocket | SmartsocketClient,
-  originSocketConnection: SocketConnection;
+    shortIdArg: string
-  funcCallData: ISocketFunctionCall;
+  ): SocketRequest<any> {
-  done = plugins.smartpromise.defer();
+    return smartsocketRef.socketRequests.find((socketRequestArg) => {
-  constructor(optionsArg: SocketRequestConstructorOptions) {
+      return socketRequestArg.shortid === shortIdArg;
+    });
+  }
+
+  // INSTANCE
+  public status: TSocketRequestStatus = 'new';
+  public side: TSocketRequestSide;
+  public shortid: string;
+  public originSocketConnection: SocketConnection;
+  public funcCallData: ISocketFunctionCallDataRequest<T>;
+  public done = plugins.smartpromise.defer<ISocketFunctionCallDataResponse<T>>();
+
+  public smartsocketRef: Smartsocket | SmartsocketClient;
+
+  constructor(
+    smartsocketRefArg: Smartsocket | SmartsocketClient,
+    optionsArg: ISocketRequestConstructorOptions<T>
+  ) {
+    this.smartsocketRef = smartsocketRefArg;
     this.side = optionsArg.side;
     this.shortid = optionsArg.shortId;
     this.funcCallData = optionsArg.funcCallData;
     this.originSocketConnection = optionsArg.originSocketConnection;
-    allSocketRequests.add(this);
+    this.smartsocketRef.socketRequests.add(this);
   }
 
   // requesting --------------------------
@@ -57,10 +77,10 @@ export class SocketRequest {
   /**
    * dispatches a socketrequest from the requesting to the receiving side
    */
-  dispatch() {
+  public dispatch(): Promise<ISocketFunctionCallDataResponse<T>> {
-    let requestData: ISocketRequestDataObject = {
+    const requestData: ISocketRequestDataObject<T> = {
       funcCallData: this.funcCallData,
-      shortId: this.shortid
+      shortId: this.shortid,
     };
     this.originSocketConnection.socket.emit('function', requestData);
     return this.done.promise;
@@ -69,10 +89,10 @@ export class SocketRequest {
   /**
    * handles the response that is received by the requesting side
    */
-  handleResponse(responseDataArg: ISocketRequestDataObject) {
+  public async handleResponse(responseDataArg: ISocketRequestDataObject<T>) {
-    plugins.smartlog.defaultLogger.log('info', 'handling response!');
+    logger.log('info', 'handling response!');
     this.done.resolve(responseDataArg.funcCallData);
-    allSocketRequests.remove(this);
+    this.smartsocketRef.socketRequests.remove(this);
   }
 
   // responding --------------------------
@@ -81,23 +101,26 @@ export class SocketRequest {
    * creates the response on the responding side
    */
   public async createResponse(): Promise<void> {
-    const targetSocketFunction: SocketFunction = helpers.getSocketFunctionByName(
+    const targetSocketFunction: SocketFunction<T> = SocketFunction.getSocketFunctionByName(
+      this.smartsocketRef,
       this.funcCallData.funcName
     );
+
     if (!targetSocketFunction) {
-      defaultLogger.log('warn', `There is no SocketFunction defined for ${this.funcCallData.funcName}`);
+      logger.log('error', `There is no SocketFunction defined for ${this.funcCallData.funcName}`);
-      defaultLogger.log('warn', `So now response is being sent.`);
       return;
     }
-    plugins.smartlog.defaultLogger.log('info', `invoking ${targetSocketFunction.name}`);
+    logger.log('info', `invoking ${targetSocketFunction.name}`);
-    targetSocketFunction.invoke(this.funcCallData).then(resultData => {
+    targetSocketFunction
-      plugins.smartlog.defaultLogger.log('info', 'got resultData. Sending it to requesting party.');
+      .invoke(this.funcCallData, this.originSocketConnection)
-      let requestData: ISocketRequestDataObject = {
+      .then((resultData) => {
-        funcCallData: resultData,
+        logger.log('info', 'got resultData. Sending it to requesting party.');
-        shortId: this.shortid
+        const responseData: ISocketRequestDataObject<T> = {
-      };
+          funcCallData: resultData,
-      this.originSocketConnection.socket.emit('functionResponse', requestData);
+          shortId: this.shortid,
-      allSocketRequests.remove(this);
+        };
-    });
+        this.originSocketConnection.socket.emit('functionResponse', responseData);
+        this.smartsocketRef.socketRequests.remove(this);
+      });
   }
 }

ts/smartsocket.classes.socketrole.ts

@@ -1,13 +1,15 @@
 import * as plugins from './smartsocket.plugins';
 
 // import classes
-import { Objectmap } from '@pushrocks/lik';
 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 SocketRoleOptions {
+export interface ISocketRoleOptions {
   name: string;
   passwordHash: string;
 }
@@ -16,14 +18,40 @@ export interface SocketRoleOptions {
  * A socketrole defines access to certain routines.
  */
 export class SocketRole {
-  name: string;
+  // STATIC
-  passwordHash: string;
+  public static getSocketRoleByName(
-  allowedFunctions = new Objectmap<SocketFunction>();
+    referenceSmartsocket: Smartsocket | SmartsocketClient,
-  constructor(optionsArg: SocketRoleOptions) {
+    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;
   }
-  addSocketFunction(socketFunctionArg: SocketFunction) {
+
+  /**
+   * adds the socketfunction to the socketrole
+   * @param socketFunctionArg
+   */
+  public addSocketFunction(socketFunctionArg: SocketFunction<any>) {
     this.allowedFunctions.add(socketFunctionArg);
   }
 }

ts/smartsocket.classes.socketserver.ts

@@ -1,8 +1,9 @@
 import * as plugins from './smartsocket.plugins';
+import * as pluginsTyped from './smartsocket.pluginstyped';
 
 // used in case no other server is supplied
-import * as http from 'http';
 import { Smartsocket } from './smartsocket.classes.smartsocket';
+import { logger } from './smartsocket.logging';
 
 /**
  * class socketServer
@@ -10,7 +11,7 @@ import { Smartsocket } from './smartsocket.classes.smartsocket';
  */
 export class SocketServer {
   private smartsocket: Smartsocket;
-  private httpServer: http.Server;
+  private httpServer: pluginsTyped.http.Server | pluginsTyped.https.Server;
   // wether httpServer is standalone
   private standaloneServer = false;
   private expressServer: any;
@@ -25,7 +26,7 @@ export class SocketServer {
    */
   public async setExternalServer(
     serverType: 'smartexpress',
-    serverArg: plugins.smartexpress.Server
+    serverArg: pluginsTyped.smartexpress.Server
   ) {
     await serverArg.startedPromise;
     this.httpServer = serverArg.httpServer;
@@ -38,7 +39,8 @@ export class SocketServer {
     if (this.httpServer) {
       return this.httpServer;
     } else {
-      this.httpServer = new http.Server();
+      const httpModule = this.smartsocket.smartenv.getSafeNodeModule('http');
+      this.httpServer = new httpModule.Server();
       this.standaloneServer = true;
       return this.httpServer;
     }
@@ -54,11 +56,14 @@ export class SocketServer {
     // in case an external server has been set "this.standaloneServer" should be false
     if (this.httpServer && this.standaloneServer) {
       if (!this.smartsocket.options.port) {
-        console.log('there should be a port specifed for smartsocket!');
+        logger.log('error', 'there should be a port specifed for smartsocket!');
         throw new Error('there should be a port specified for smartsocket');
       }
       this.httpServer.listen(this.smartsocket.options.port, () => {
-        console.log(`Server started in standalone mode on ${this.smartsocket.options.port}`);
+        logger.log(
+          'success',
+          `Server started in standalone mode on ${this.smartsocket.options.port}`
+        );
         done.resolve();
       });
     } else {

ts/smartsocket.classes.socketstats.ts

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

ts/smartsocket.helpers.ts

@@ -1,60 +0,0 @@
-import * as plugins from './smartsocket.plugins';
-
-// classes
-import { Smartsocket } from './smartsocket.classes.smartsocket';
-import { SocketFunction, allSocketFunctions } from './smartsocket.classes.socketfunction';
-import {
-  SocketConnection,
-  ISocketConnectionAuthenticationObject
-} from './smartsocket.classes.socketconnection';
-import {
-  SocketRequest,
-  allSocketRequests,
-  TSocketRequestSide
-} from './smartsocket.classes.socketrequest';
-import { SocketRole } from './smartsocket.classes.socketrole';
-
-// SocketConnection helpers
-export let checkPasswordForRole = (
-  dataArg: ISocketConnectionAuthenticationObject,
-  referenceSmartsocket: Smartsocket
-): boolean => {
-  let targetPasswordHash = getSocketRoleByName(dataArg.role, referenceSmartsocket).passwordHash;
-  let computedCompareHash = plugins.smarthash.sha256FromStringSync(dataArg.password);
-  return targetPasswordHash === computedCompareHash;
-};
-
-// SocketFunction helpers
-export let getSocketFunctionByName = (functionNameArg: string): SocketFunction => {
-  return allSocketFunctions.find(socketFunctionArg => {
-    return socketFunctionArg.name === functionNameArg;
-  });
-};
-
-// SocketRequest helpers
-
-/**
- * get corresponding Socketrequest instance by shortId
- */
-export let getSocketRequestById = (
-  shortIdArg: string,
-  requestSide?: TSocketRequestSide
-): SocketRequest => {
-  return allSocketRequests.find(socketRequestArg => {
-    return socketRequestArg.shortid === shortIdArg;
-  });
-};
-
-// SocketRole helpers
-
-/**
- * get corresponding SocketRole instance by name
- */
-export let getSocketRoleByName = (
-  socketRoleNameArg: string,
-  referenceSmartsocket: Smartsocket
-): SocketRole => {
-  return referenceSmartsocket.socketRoles.find(socketRoleArg => {
-    return socketRoleArg.name === socketRoleNameArg;
-  });
-};

ts/smartsocket.logging.ts

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

ts/smartsocket.plugins.ts

@@ -1,21 +1,27 @@
+// apiglobal scope
+import * as typedrequestInterfaces from '@apiglobal/typedrequest-interfaces';
+
+export { typedrequestInterfaces };
+
+// pushrocks scope
+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 smartlog from '@pushrocks/smartlog';
-import * as smarthash from '@pushrocks/smarthash';
 import * as smartdelay from '@pushrocks/smartdelay';
-import * as smartexpress from '@pushrocks/smartexpress';
 import * as smartpromise from '@pushrocks/smartpromise';
-import * as shortid from 'shortid';
+import * as smarttime from '@pushrocks/smarttime';
-import * as socketIo from 'socket.io';
+import * as smartrx from '@pushrocks/smartrx';
-import * as socketIoClient from 'socket.io-client';
 
 export {
+  isohash,
+  isounique,
   lik,
+  smartenv,
   smartlog,
-  smarthash,
   smartdelay,
-  smartexpress,
   smartpromise,
-  shortid,
+  smarttime,
-  socketIo,
+  smartrx,
-  socketIoClient
 };

ts/smartsocket.pluginstyped.ts

@@ -0,0 +1,16 @@
+// node native
+import type http from 'http';
+import type https from 'https';
+
+export { http, https };
+
+// pushrocks scope
+import type * as smartexpress from '@pushrocks/smartexpress';
+
+export { smartexpress };
+
+// third party scope
+import type socketIo from 'socket.io';
+import type socketIoClient from 'socket.io-client';
+
+export { socketIo, socketIoClient };