2.0.17

fix(core): update
2.0.16
2023-03-29 16:07:54 +02:00 · 2023-03-29 16:07:54 +02:00 · 2023-03-20 18:51:02 +01:00 · 2023-03-20 18:51:02 +01:00 · 2023-02-07 12:32:48 +01:00 · 2023-02-07 12:32:48 +01:00
46 changed files with 6025 additions and 531 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,3 +1,20 @@
-node_modules/
+.nogit/
+
+# artifacts
 coverage/
-docs/
+public/
+pages/
+
+# installs
+node_modules/
+
+# caches
+.yarn/
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_*/
+
+# custom
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -1,36 +1,128 @@
-image: hosttoday/ht-docker-node:npmts
+# gitzone ci_default
+image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+
+cache:
+  paths:
+    - .npmci_cache/
+  key: '$CI_BUILD_STAGE'

 stages:
- test
- release
+  - security
+  - test
+  - release
+  - metadata

-testLEGACY:
+before_script:
+  - pnpm install -g pnpm
+  - pnpm install -g @shipzone/npmci
+  - npmci npm prepare
+
+# ====================
+# security stage
+# ====================
+# ====================
+# security stage
+# ====================
+auditProductionDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  stage: security
+  script:
+     - npmci command npm config set registry https://registry.npmjs.org
+     - npmci command pnpm audit --audit-level=high --prod
+  tags:
+    - lossless
+    - docker
+  allow_failure: true
+
+auditDevDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  stage: security
+  script:
+    - npmci command npm config set registry https://registry.npmjs.org
+    - npmci command pnpm audit --audit-level=high --dev
+  tags:
+    - lossless
+    - docker
+  allow_failure: true
+
+# ====================
+# test stage
+# ====================
+
+testStable:
  stage: test
  script:
-    - npmci test legacy
+    - npmci node install stable
+    - npmci npm install
+    - npmci npm test
+  coverage: /\d+.?\d+?\%\s*coverage/
  tags:
    - docker

-testLTS:
+testBuild:
  stage: test
  script:
-    - npmci test lts
-  tags:
-    - docker
-    
-testSTABLE:
-  stage: test
-  script:
-    - npmci test stable
+    - npmci node install stable
+    - npmci npm install
+    - npmci npm build
+  coverage: /\d+.?\d+?\%\s*coverage/
  tags:
    - docker

 release:
  stage: release
-  environment: npmjs-com_registry
  script:
-    - npmci publish
+    - npmci node install stable
+    - npmci npm publish
  only:
    - tags
  tags:
+    - lossless
    - docker
+    - notpriv
+
+# ====================
+# metadata stage
+# ====================
+codequality:
+  stage: metadata
+  allow_failure: true
+  only:
+    - tags
+  script:
+    - npmci command npm install -g typescript
+    - npmci npm prepare
+    - npmci npm install
+  tags:
+    - lossless
+    - docker
+    - priv
+
+trigger:
+  stage: metadata
+  script:
+    - npmci trigger
+  only:
+    - tags
+  tags:
+    - lossless
+    - docker
+    - notpriv
+
+pages:
+  stage: metadata
+  script:
+    - npmci node install stable
+    - npmci npm install
+    - npmci command npm run buildDocs
+  tags:
+    - lossless
+    - docker
+    - notpriv
+  only:
+    - tags
+  artifacts:
+    expire_in: 1 week
+    paths:
+      - public
+  allow_failure: true
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@ -0,0 +1,11 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "command": "npm test",
+      "name": "Run npm test",
+      "request": "launch",
+      "type": "node-terminal"
+    }
+  ]
+}
--- a/.vscode/settings.json
+++ b/.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"]
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}
--- a/README.md
+++ b/README.md
@ -1,64 +0,0 @@
-# smartsocket
-easy and secure websocket communication, Typescript ready
-
-## Status
-[![build status](https://gitlab.com/pushrocks/smartsocket/badges/master/build.svg)](https://gitlab.com/pushrocks/smartsocket/commits/master)
-
-## Usage
-We recommend the use of typescript.
-Under the hood we use socket.io and shortid for managed data exchange.
-
-### Serverside
-```typescript
-import * as smartsocket from "smartsocket";
-
-let mySmartsocket = new smartsocket.Smartsocket({
-    port: 3000 // the port smartsocket will listen on
-});
-
-let mySocketRole = new smartsocket.SocketRole({
-    name: "someRoleName",
-    passwordHash: "someHashedString"
-});
-
-let mySocketFunction = new smartsocket.SocketFunction({
-    name:"newService",
-    func:(data) => {
-        
-    }, the function to execute
-    roles:[mySocketRole] // all roles that have access to a specific function
-});
-
-mySmartsocket.registerRole(mySocketRole);
-mySmartsocket.clientCall.select("client1","restart",data)
-    .then((responseData) => {
-
-    });
-```
-
-#### Client side
-```typescript
-import * as smartsocket from "smartsocket";
-
-let mySmartsocketClient = new smartsocket.SmartsocketClient({
-    url: "somedomain.com", // url, note: will only work over https, no http supported.
-    port: 3000
-    role:"dockerhost", // some role, in this example a dockerhost vm,
-    password:"somePassword",
-    alias:"client1"
-});
-
-let mySocketFunction2 = new smartsocket.SocketFunction({
-    name:"restart",
-    func:(data) => {}, the function to execute
-});
-
-mySmartsocketClient.registerFunction(mySocketFunction2);
-
-mySmartsocketClient.serverCall("newService",data)
-    .then((responseData) => {
-        
-    });;
-```
-
-> **NOTE:** you can easily chain dependent requests on eiter the server or client side with promises. `data` is always a js object that you can design for your specific. It supports buffers for large binary data network exchange.
--- a/dist/index.d.ts
+++ b/dist/index.d.ts
@ -1,2 +0,0 @@
-export * from "./smartsocket.classes.smartsocket";
-export * from "./smartsocket.classes.smartsocketclient";
--- a/dist/index.js
+++ b/dist/index.js
@ -1,7 +0,0 @@
-"use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-__export(require("./smartsocket.classes.smartsocket"));
-__export(require("./smartsocket.classes.smartsocketclient"));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBRUEsaUJBQWMsbUNBQW1DLENBQUMsRUFBQTtBQUNsRCxpQkFBYyx5Q0FBeUMsQ0FBQyxFQUFBIn0=
--- a/dist/smartsocket.classes.smartsocket.d.ts
+++ b/dist/smartsocket.classes.smartsocket.d.ts
@ -1,29 +0,0 @@
-/// <reference types="socket.io" />
-import { Objectmap } from "lik";
-import { SocketRole } from "./smartsocket.classes.socketrole";
-export interface ISocketObject {
-    alias?: string;
-    authenticated: boolean;
-    role?: string;
-    socket: SocketIO.Socket;
-}
-export interface ISmartsocketConstructorOptions {
-    port: number;
-}
-export declare class Smartsocket {
-    options: ISmartsocketConstructorOptions;
-    io: SocketIO.Server;
-    openSockets: Objectmap;
-    registeredRoles: Objectmap;
-    constructor(optionsArg: ISmartsocketConstructorOptions);
-    /**
-     * the standard handler for new socket connections
-     */
-    private _handleSocket(socket);
-    registerFunctions(socketRoleArg: SocketRole): void;
-    /**
-     * starts listening to incling sockets:
-     */
-    startServer: () => void;
-    closeServer: () => void;
-}
--- a/dist/smartsocket.classes.smartsocket.js
+++ b/dist/smartsocket.classes.smartsocket.js
@ -1,51 +0,0 @@
-"use strict";
-const plugins = require("./smartsocket.plugins");
-const helpers = require("./smartsocket.helpers");
-// classes
-const lik_1 = require("lik");
-;
-;
-class Smartsocket {
-    constructor(optionsArg) {
-        this.openSockets = new lik_1.Objectmap();
-        this.registeredRoles = new lik_1.Objectmap();
-        /**
-         * starts listening to incling sockets:
-         */
-        this.startServer = () => {
-            this.io = plugins.socketIo(this.options.port);
-            this.io.on('connection', (socketArg) => {
-                this._handleSocket(socketArg);
-            });
-        };
-        this.closeServer = () => {
-            this.openSockets.forEach((socketObjectArg) => {
-                plugins.beautylog.log(`disconnect socket with >>alias ${socketObjectArg.alias}`);
-                socketObjectArg.socket.disconnect();
-            });
-            this.openSockets.wipe();
-            this.io.close();
-        };
-        this.options = optionsArg;
-    }
-    ;
-    /**
-     * the standard handler for new socket connections
-     */
-    _handleSocket(socket) {
-        let socketObject = {
-            socket: socket,
-            authenticated: false
-        };
-        plugins.beautylog.log("Socket connected. Trying to authenticate...");
-        this.openSockets.add(socketObject);
-        helpers.authenticateSocket(socketObject)
-            .then();
-    }
-    registerFunctions(socketRoleArg) {
-        this.registeredRoles.add(socketRoleArg);
-    }
-    ;
-}
-exports.Smartsocket = Smartsocket;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zbWFydHNvY2tldC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmNsYXNzZXMuc21hcnRzb2NrZXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE1BQVksT0FBTyxXQUFNLHVCQUF1QixDQUFDLENBQUE7QUFDakQsTUFBWSxPQUFPLFdBQU0sdUJBQXVCLENBQUMsQ0FBQTtBQUVqRCxVQUFVO0FBQ1Ysc0JBQTBCLEtBQUssQ0FBQyxDQUFBO0FBVS9CLENBQUM7QUFLRCxDQUFDO0FBRUY7SUFLSSxZQUFZLFVBQTBDO1FBRnRELGdCQUFXLEdBQUcsSUFBSSxlQUFTLEVBQUUsQ0FBQztRQUM5QixvQkFBZSxHQUFHLElBQUksZUFBUyxFQUFFLENBQUM7UUF3QmxDOztXQUVHO1FBRUgsZ0JBQVcsR0FBRztZQUNWLElBQUksQ0FBQyxFQUFFLEdBQUcsT0FBTyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQzlDLElBQUksQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLFlBQVksRUFBRSxDQUFDLFNBQVM7Z0JBQy9CLElBQUksQ0FBQyxhQUFhLENBQUMsU0FBUyxDQUFDLENBQUM7WUFDbEMsQ0FBQyxDQUFDLENBQUM7UUFDUCxDQUFDLENBQUE7UUFDRCxnQkFBVyxHQUFHO1lBQ1YsSUFBSSxDQUFDLFdBQVcsQ0FBQyxPQUFPLENBQUMsQ0FBQyxlQUE4QjtnQkFDcEQsT0FBTyxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsa0NBQWtDLGVBQWUsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDO2dCQUNqRixlQUFlLENBQUMsTUFBTSxDQUFDLFVBQVUsRUFBRSxDQUFDO1lBQ3hDLENBQUMsQ0FBQyxDQUFDO1lBQ0gsSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUN4QixJQUFJLENBQUMsRUFBRSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ3BCLENBQUMsQ0FBQTtRQXZDRyxJQUFJLENBQUMsT0FBTyxHQUFHLFVBQVUsQ0FBQztJQUM5QixDQUFDOztJQUVEOztPQUVHO0lBQ0ssYUFBYSxDQUFDLE1BQU07UUFDeEIsSUFBSSxZQUFZLEdBQWtCO1lBQzlCLE1BQU0sRUFBRSxNQUFNO1lBQ2QsYUFBYSxFQUFFLEtBQUs7U0FDdkIsQ0FBQztRQUNGLE9BQU8sQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLDZDQUE2QyxDQUFDLENBQUE7UUFDcEUsSUFBSSxDQUFDLFdBQVcsQ0FBQyxHQUFHLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDbkMsT0FBTyxDQUFDLGtCQUFrQixDQUFDLFlBQVksQ0FBQzthQUNuQyxJQUFJLEVBQUUsQ0FBQztJQUNoQixDQUFDO0lBRUQsaUJBQWlCLENBQUMsYUFBd0I7UUFDdEMsSUFBSSxDQUFDLGVBQWUsQ0FBQyxHQUFHLENBQUMsYUFBYSxDQUFDLENBQUM7SUFDNUMsQ0FBQzs7QUFxQkwsQ0FBQztBQTlDWSxtQkFBVyxjQThDdkIsQ0FBQSJ9
--- a/dist/smartsocket.classes.smartsocketclient.d.ts
+++ b/dist/smartsocket.classes.smartsocketclient.d.ts
@ -1,10 +0,0 @@
-/**
- * interface for class SmartsocketClient
- */
-export interface ISmartsocketClientOptions {
-    port: number;
-    url: string;
-}
-export declare class SmartsocketClient {
-    constructor();
-}
--- a/dist/smartsocket.classes.smartsocketclient.js
+++ b/dist/smartsocket.classes.smartsocketclient.js
@ -1,7 +0,0 @@
-"use strict";
-class SmartsocketClient {
-    constructor() {
-    }
-}
-exports.SmartsocketClient = SmartsocketClient;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zbWFydHNvY2tldGNsaWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmNsYXNzZXMuc21hcnRzb2NrZXRjbGllbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQVVBO0lBQ0k7SUFFQSxDQUFDO0FBQ0wsQ0FBQztBQUpZLHlCQUFpQixvQkFJN0IsQ0FBQSJ9
--- a/dist/smartsocket.classes.socketfunction.d.ts
+++ b/dist/smartsocket.classes.socketfunction.d.ts
@ -1,12 +0,0 @@
-import { SocketRole } from "./smartsocket.classes.socketrole";
-export interface SocketFunctionOptions {
-    name: string;
-    func: any;
-    roles: SocketRole[];
-}
-export declare class SocketFunction {
-    name: string;
-    func: any;
-    roles: SocketRole[];
-    constructor(optionsArg: SocketFunctionOptions);
-}
--- a/dist/smartsocket.classes.socketfunction.js
+++ b/dist/smartsocket.classes.socketfunction.js
@ -1,12 +0,0 @@
-"use strict";
-;
-class SocketFunction {
-    constructor(optionsArg) {
-        this.name = optionsArg.name;
-        this.func = optionsArg.func;
-        this.roles = optionsArg.roles;
-    }
-    ;
-}
-exports.SocketFunction = SocketFunction;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRmdW5jdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmNsYXNzZXMuc29ja2V0ZnVuY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQVlDLENBQUM7QUFFRjtJQUlJLFlBQVksVUFBaUM7UUFDekMsSUFBSSxDQUFDLElBQUksR0FBRyxVQUFVLENBQUMsSUFBSSxDQUFDO1FBQzVCLElBQUksQ0FBQyxJQUFJLEdBQUcsVUFBVSxDQUFDLElBQUksQ0FBQztRQUM1QixJQUFJLENBQUMsS0FBSyxHQUFHLFVBQVUsQ0FBQyxLQUFLLENBQUM7SUFDbEMsQ0FBQzs7QUFDTCxDQUFDO0FBVFksc0JBQWMsaUJBUzFCLENBQUEifQ==
--- a/dist/smartsocket.classes.socketrole.d.ts
+++ b/dist/smartsocket.classes.socketrole.d.ts
@ -1,15 +0,0 @@
-/**
- * interface for class SocketRole
- */
-export interface SocketRoleOptions {
-    name: string;
-    passwordHash: string;
-}
-/**
- * A socketrole defines access to certain routines.
- */
-export declare class SocketRole {
-    name: string;
-    passwordHash: string;
-    constructor(optionsArg: SocketRoleOptions);
-}
--- a/dist/smartsocket.classes.socketrole.js
+++ b/dist/smartsocket.classes.socketrole.js
@ -1,12 +0,0 @@
-"use strict";
-/**
- * A socketrole defines access to certain routines.
- */
-class SocketRole {
-    constructor(optionsArg) {
-        this.name = optionsArg.name;
-        this.passwordHash = optionsArg.passwordHash;
-    }
-}
-exports.SocketRole = SocketRole;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRyb2xlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRyb2xlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFjQTs7R0FFRztBQUNIO0lBR0ksWUFBWSxVQUE0QjtRQUNwQyxJQUFJLENBQUMsSUFBSSxHQUFHLFVBQVUsQ0FBQyxJQUFJLENBQUM7UUFDNUIsSUFBSSxDQUFDLFlBQVksR0FBRyxVQUFVLENBQUMsWUFBWSxDQUFDO0lBQ2hELENBQUM7QUFDTCxDQUFDO0FBUFksa0JBQVUsYUFPdEIsQ0FBQSJ9
--- a/dist/smartsocket.helpers.d.ts
+++ b/dist/smartsocket.helpers.d.ts
@ -1,7 +0,0 @@
-/// <reference types="q" />
-import * as plugins from "./smartsocket.plugins";
-import { ISocketObject } from "./smartsocket.classes.smartsocket";
-/**
- * authenticate a socket
- */
-export declare let authenticateSocket: (socketObjectArg: ISocketObject) => plugins.q.Promise<{}>;
--- a/dist/smartsocket.helpers.js
+++ b/dist/smartsocket.helpers.js
@ -1,28 +0,0 @@
-"use strict";
-const plugins = require("./smartsocket.plugins");
-/**
- * authenticate a socket
- */
-exports.authenticateSocket = (socketObjectArg) => {
-    let done = plugins.q.defer();
-    socketObjectArg.socket.on("dataAuth", dataArg => {
-        plugins.beautylog.log("received authentication data. now hashing and comparing...");
-        socketObjectArg.socket.removeListener("dataAuth", () => { });
-        if ((true)) {
-            socketObjectArg.alias = dataArg.alias;
-            socketObjectArg.authenticated = true;
-            socketObjectArg.role = dataArg.role;
-            socketObjectArg.socket.emit("authenticated");
-            plugins.beautylog.ok(`socket with >>alias ${socketObjectArg.alias} >>role ${socketObjectArg.role} is authenticated!`);
-            done.resolve(socketObjectArg);
-        }
-        else {
-            socketObjectArg.socket.disconnect();
-            done.reject("not authenticated");
-        }
-        ;
-    });
-    socketObjectArg.socket.emit("requestAuth");
-    return done.promise;
-};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmhlbHBlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE1BQVksT0FBTyxXQUFNLHVCQUF1QixDQUFDLENBQUE7QUFRakQ7O0dBRUc7QUFDUSwwQkFBa0IsR0FBRyxDQUFDLGVBQThCO0lBQzNELElBQUksSUFBSSxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDN0IsZUFBZSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsVUFBVSxFQUFFLE9BQU87UUFDekMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsNERBQTRELENBQUMsQ0FBQztRQUNwRixlQUFlLENBQUMsTUFBTSxDQUFDLGNBQWMsQ0FBQyxVQUFVLEVBQUUsUUFBUSxDQUFDLENBQUMsQ0FBQztRQUM3RCxFQUFFLENBQUEsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUEsQ0FBQztZQUNQLGVBQWUsQ0FBQyxLQUFLLEdBQUcsT0FBTyxDQUFDLEtBQUssQ0FBQTtZQUNyQyxlQUFlLENBQUMsYUFBYSxHQUFHLElBQUksQ0FBQztZQUNyQyxlQUFlLENBQUMsSUFBSSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUM7WUFDcEMsZUFBZSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsZUFBZSxDQUFDLENBQUM7WUFDN0MsT0FBTyxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsdUJBQXVCLGVBQWUsQ0FBQyxLQUFLLFdBQVcsZUFBZSxDQUFDLElBQUksb0JBQW9CLENBQUMsQ0FBQTtZQUNySCxJQUFJLENBQUMsT0FBTyxDQUFDLGVBQWUsQ0FBQyxDQUFDO1FBQ2xDLENBQUM7UUFBQyxJQUFJLENBQUMsQ0FBQztZQUNKLGVBQWUsQ0FBQyxNQUFNLENBQUMsVUFBVSxFQUFFLENBQUM7WUFDcEMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDO1FBQ3JDLENBQUM7UUFBQSxDQUFDO0lBQ04sQ0FBQyxDQUFDLENBQUM7SUFDSCxlQUFlLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsQ0FBQztJQUMzQyxNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQztBQUN4QixDQUFDLENBQUMifQ==
--- a/dist/smartsocket.plugins.d.ts
+++ b/dist/smartsocket.plugins.d.ts
@ -1,7 +0,0 @@
-import "typings-global";
-export import beautylog = require("beautylog");
-export import lik = require("lik");
-export import q = require("q");
-export import socketIo = require("socket.io");
-export import socketIoClient = require("socket.io-client");
-export import taskbuffer = require("taskbuffer");
--- a/dist/smartsocket.plugins.js
+++ b/dist/smartsocket.plugins.js
@ -1,9 +0,0 @@
-"use strict";
-require("typings-global");
-exports.beautylog = require("beautylog");
-exports.lik = require("lik");
-exports.q = require("q");
-exports.socketIo = require("socket.io");
-exports.socketIoClient = require("socket.io-client");
-exports.taskbuffer = require("taskbuffer");
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFFBQU8sZ0JBQWdCLENBQUMsQ0FBQTtBQUNWLGlCQUFTLFdBQVcsV0FBVyxDQUFDLENBQUM7QUFDakMsV0FBRyxXQUFZLEtBQUssQ0FBQyxDQUFDO0FBQ3RCLFNBQUMsV0FBVyxHQUFHLENBQUMsQ0FBQztBQUNqQixnQkFBUSxXQUFXLFdBQVcsQ0FBQyxDQUFDO0FBQ2hDLHNCQUFjLFdBQVcsa0JBQWtCLENBQUMsQ0FBQztBQUM3QyxrQkFBVSxXQUFXLFlBQVksQ0FBQyxDQUFDIn0=
--- a/npmextra.json
+++ b/npmextra.json
@ -0,0 +1,18 @@
+{
+  "gitzone": {
+    "projectType": "npm",
+    "module": {
+      "githost": "gitlab.com",
+      "gitscope": "pushrocks",
+      "gitrepo": "smartsocket",
+      "description": "easy and secure websocket communication",
+      "npmPackagename": "@pushrocks/smartsocket",
+      "license": "MIT",
+      "projectDomain": "push.rocks"
+    }
+  },
+  "npmci": {
+    "npmGlobalTools": [],
+    "npmAccessLevel": "public"
+  }
+}
--- a/package.json
+++ b/package.json
@ -1,11 +1,14 @@
 {
-  "name": "smartsocket",
-  "version": "1.0.3",
-  "description": "easy and secure websocket communication, Typescript ready",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "name": "@pushrocks/smartsocket",
+  "version": "2.0.17",
+  "description": "easy and secure websocket communication",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
  "scripts": {
-    "test": "(npmts)"
+    "test": "(tstest test/)",
+    "build": "(tsbuild --web --allowimplicitany && tsbundle --from ./ts/index.ts --to dist_bundle/bundle.js)",
+    "buildDocs": "tsdoc"
  },
  "repository": {
    "type": "git",
@ -18,19 +21,44 @@
  },
  "homepage": "https://gitlab.com/pushrocks/smartsocket#README",
  "dependencies": {
-    "@types/q": "0.x.x",
-    "@types/socket.io": "^1.4.26",
-    "@types/socket.io-client": "^1.4.26",
-    "beautylog": "^5.0.20",
-    "lik": "^1.0.10",
-    "q": "^1.4.1",
-    "socket.io": "^1.4.8",
-    "socket.io-client": "^1.4.8",
-    "taskbuffer": "^1.0.7"
+    "@apiglobal/typedrequest-interfaces": "^2.0.1",
+    "@pushrocks/isohash": "^2.0.0",
+    "@pushrocks/isounique": "^1.0.5",
+    "@pushrocks/lik": "^6.0.2",
+    "@pushrocks/smartdelay": "^2.0.13",
+    "@pushrocks/smartenv": "^5.0.5",
+    "@pushrocks/smartexpress": "^4.0.34",
+    "@pushrocks/smartjson": "^5.0.1",
+    "@pushrocks/smartlog": "^3.0.1",
+    "@pushrocks/smartpromise": "^3.1.7",
+    "@pushrocks/smartrx": "^3.0.0",
+    "@pushrocks/smarttime": "^4.0.1",
+    "engine.io": "6.3.1",
+    "socket.io": "4.5.4",
+    "socket.io-client": "4.5.4"
  },
  "devDependencies": {
-    "npmts-g": "^5.2.8",
-    "should": "^10.0.0",
-    "typings-test": "^1.0.1"
-  }
+    "@gitzone/tsbuild": "^2.1.63",
+    "@gitzone/tsbundle": "^2.0.7",
+    "@gitzone/tsrun": "^1.2.37",
+    "@gitzone/tstest": "^1.0.72",
+    "@pushrocks/tapbundle": "^5.0.4",
+    "@types/node": "^18.15.11"
+  },
+  "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"
+  ]
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/readme.md
+++ b/readme.md
@ -0,0 +1,120 @@
+# @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)
+
+## 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.
+
+## Legal
+> MIT licensed | **&copy;** [Task Venture Capital GmbH](https://task.vc)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
--- a/test/test.d.ts
+++ b/test/test.d.ts
@ -1,2 +0,0 @@
-import "typings-test";
-import "should";
--- a/test/test.expressserver.ts
+++ b/test/test.expressserver.ts
@ -0,0 +1,103 @@
+// tslint:disable-next-line:no-implicit-dependencies
+import { expect, expectAsync, tap } from '@pushrocks/tapbundle';
+
+import * as isohash from '@pushrocks/isohash';
+import * as smartexpress from '@pushrocks/smartexpress';
+
+import * as smartsocket from '../ts/index.js';
+
+let testSmartsocket: smartsocket.Smartsocket;
+let testSmartsocketClient: smartsocket.SmartsocketClient;
+let testSocketFunction1: smartsocket.SocketFunction<any>;
+let myseServer: smartexpress.Server;
+
+const testConfig = {
+  port: 3000,
+};
+
+// class smartsocket
+tap.test('should create a new smartsocket', async () => {
+  testSmartsocket = new smartsocket.Smartsocket({ alias: 'testserver', port: testConfig.port });
+  expect(testSmartsocket).toBeInstanceOf(smartsocket.Smartsocket);
+});
+
+tap.test('Should accept an smartExpressServer as server', async () => {
+  myseServer = new smartexpress.Server({
+    cors: true,
+    forceSsl: false,
+    port: testConfig.port,
+  });
+
+  testSmartsocket.setExternalServer('smartexpress', myseServer);
+
+  await myseServer.start();
+});
+
+// class SocketFunction
+tap.test('should register a new Function', async () => {
+  testSocketFunction1 = new smartsocket.SocketFunction({
+    funcDef: async (dataArg, socketConnectionArg) => {
+      return dataArg;
+    },
+    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 () => {
+  testSmartsocketClient = new smartsocket.SmartsocketClient({
+    port: testConfig.port,
+    url: 'http://localhost',
+    alias: 'testClient1',
+  });
+  testSmartsocketClient.addSocketFunction(testSocketFunction1);
+  await testSmartsocketClient.connect();
+});
+
+tap.test('client should disconnect and reconnect', async (tools) => {
+  await testSmartsocketClient.disconnect();
+  await tools.delayFor(100);
+  await testSmartsocketClient.connect();
+});
+
+tap.test('2 clients should connect in parallel', async () => {
+  // TODO: implement parallel test
+});
+
+tap.test('should be able to make a functionCall from client to server', async () => {
+  const totalCycles = 20000;
+  let counter = 0;
+  let startTime = Date.now();
+  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 () => {});
+
+// terminate
+tap.test('should close the server', async () => {
+  await testSmartsocket.stop();
+  await myseServer.stop();
+});
+
+tap.start();
--- a/test/test.js
+++ b/test/test.js
@ -1,37 +0,0 @@
-"use strict";
-require("typings-test");
-require("should");
-const socketIoClient = require("socket.io-client");
-const smartsocket = require("../dist/index");
-let testSmartsocket;
-describe("smartsocket", function () {
-    it("should create a new smartsocket", function () {
-        testSmartsocket = new smartsocket.Smartsocket({ port: 3000 });
-        testSmartsocket.should.be.instanceOf(smartsocket.Smartsocket);
-    });
-    it("should register a new Function", function () {
-    });
-    it("should start listening when .started is called", function () {
-        testSmartsocket.startServer();
-    });
-    it("should react to a new websocket connection", function (done) {
-        this.timeout(10000);
-        let socket = socketIoClient("http://localhost:3000", {});
-        socket.on("requestAuth", function () {
-            console.log("server requested authentication");
-            socket.emit("dataAuth", {
-                role: "coreflowContainer",
-                password: "somePassword",
-                alias: "coreflow1"
-            });
-            socket.on("authenticated", () => {
-                console.log("client is authenticated");
-                done();
-            });
-        });
-    });
-    it("should close the server", function () {
-        testSmartsocket.closeServer();
-    });
-});
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFFBQU8sY0FBYyxDQUFDLENBQUE7QUFDdEIsUUFBTyxRQUFRLENBQUMsQ0FBQTtBQUNoQixNQUFPLGNBQWMsV0FBVyxrQkFBa0IsQ0FBQyxDQUFDO0FBQ3BELE1BQU8sV0FBVyxXQUFXLGVBQWUsQ0FBQyxDQUFDO0FBRTlDLElBQUksZUFBd0MsQ0FBQztBQUU3QyxRQUFRLENBQUMsYUFBYSxFQUFFO0lBQ3BCLEVBQUUsQ0FBQyxpQ0FBaUMsRUFBRTtRQUNsQyxlQUFlLEdBQUcsSUFBSSxXQUFXLENBQUMsV0FBVyxDQUFDLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7UUFDOUQsZUFBZSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLFdBQVcsQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNsRSxDQUFDLENBQUMsQ0FBQztJQUNILEVBQUUsQ0FBQyxnQ0FBZ0MsRUFBQztJQUVwQyxDQUFDLENBQUMsQ0FBQTtJQUNGLEVBQUUsQ0FBQyxnREFBZ0QsRUFBQztRQUNoRCxlQUFlLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDbEMsQ0FBQyxDQUFDLENBQUE7SUFDRixFQUFFLENBQUMsNENBQTRDLEVBQUUsVUFBVSxJQUFJO1FBQzNELElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDcEIsSUFBSSxNQUFNLEdBQUcsY0FBYyxDQUFDLHVCQUF1QixFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQ3pELE1BQU0sQ0FBQyxFQUFFLENBQUMsYUFBYSxFQUFFO1lBQ3JCLE9BQU8sQ0FBQyxHQUFHLENBQUMsaUNBQWlDLENBQUMsQ0FBQztZQUMvQyxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRTtnQkFDcEIsSUFBSSxFQUFFLG1CQUFtQjtnQkFDekIsUUFBUSxFQUFFLGNBQWM7Z0JBQ3hCLEtBQUssRUFBRSxXQUFXO2FBQ3JCLENBQUMsQ0FBQztZQUNILE1BQU0sQ0FBQyxFQUFFLENBQUMsZUFBZSxFQUFDO2dCQUN0QixPQUFPLENBQUMsR0FBRyxDQUFDLHlCQUF5QixDQUFDLENBQUM7Z0JBQ3ZDLElBQUksRUFBRSxDQUFDO1lBQ1gsQ0FBQyxDQUFDLENBQUM7UUFDUCxDQUFDLENBQUMsQ0FBQztJQUNQLENBQUMsQ0FBQyxDQUFDO0lBQ0gsRUFBRSxDQUFDLHlCQUF5QixFQUFDO1FBQ3pCLGVBQWUsQ0FBQyxXQUFXLEVBQUUsQ0FBQztJQUNsQyxDQUFDLENBQUMsQ0FBQTtBQUNOLENBQUMsQ0FBQyxDQUFDIn0=
--- a/test/test.reconnect.ts
+++ b/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();
--- a/test/test.tagging.ts
+++ b/test/test.tagging.ts
@ -0,0 +1,147 @@
+// 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: 'testserver2', port: testConfig.port });
+  expect(testSmartsocket).toBeInstanceOf(smartsocket.Smartsocket);
+});
+
+// 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);
+});
+
+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 () => {
+  testSmartsocketClient = new smartsocket.SmartsocketClient({
+    port: testConfig.port,
+    url: 'http://localhost',
+    alias: 'testClient1',
+  });
+  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('2 clients should connect in parallel', async () => {
+  // TODO: implement parallel test
+});
+
+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 (tools) => {
+  await testSmartsocketClient.disconnect();
+  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();
+});
+
+tap.start();
--- a/test/test.ts
+++ b/test/test.ts
@ -1,38 +0,0 @@
-import "typings-test";
-import "should";
-import socketIoClient = require("socket.io-client");
-import smartsocket = require("../dist/index");
-
-let testSmartsocket: smartsocket.Smartsocket;
-
-describe("smartsocket", function () {
-    it("should create a new smartsocket", function () {
-        testSmartsocket = new smartsocket.Smartsocket({ port: 3000 });
-        testSmartsocket.should.be.instanceOf(smartsocket.Smartsocket);
-    });
-    it("should register a new Function",function(){
-        
-    })
-    it("should start listening when .started is called",function(){
-        testSmartsocket.startServer();
-    })
-    it("should react to a new websocket connection", function (done) {
-        this.timeout(10000);
-        let socket = socketIoClient("http://localhost:3000", {});
-        socket.on("requestAuth", function () {
-            console.log("server requested authentication");
-            socket.emit("dataAuth", {
-                role: "coreflowContainer",
-                password: "somePassword",
-                alias: "coreflow1"
-            });
-            socket.on("authenticated",() => {
-                console.log("client is authenticated");
-                done();
-            });
-        });
-    });
-    it("should close the server",function(){
-        testSmartsocket.closeServer();
-    })
-});
--- a/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@pushrocks/smartsocket',
+  version: '2.0.17',
+  description: 'easy and secure websocket communication'
+}
--- a/ts/index.ts
+++ b/ts/index.ts
@ -1,4 +1,7 @@
-import * as plugins from "./smartsocket.plugins";
+// export main classes
+export * from './smartsocket.classes.smartsocket.js';
+export * from './smartsocket.classes.smartsocketclient.js';

-export * from "./smartsocket.classes.smartsocket";
-export * from "./smartsocket.classes.smartsocketclient";
+// export further classes and objects
+export * from './smartsocket.classes.socketfunction.js';
+export * from './smartsocket.classes.socketconnection.js';
--- a/ts/interfaces/connection.ts
+++ b/ts/interfaces/connection.ts
@ -0,0 +1,11 @@
+export interface IRequestAuthPayload {
+  serverAlias: string;
+}
+
+export type TConnectionStatus =
+  | 'new'
+  | 'connecting'
+  | 'connected'
+  | 'disconnecting'
+  | 'disconnected'
+  | 'timedOut';
--- a/ts/interfaces/index.ts
+++ b/ts/interfaces/index.ts
@ -0,0 +1,2 @@
+export * from './connection.js';
+export * from './tag.js';
--- a/ts/interfaces/tag.ts
+++ b/ts/interfaces/tag.ts
@ -0,0 +1,6 @@
+export interface ITag<T = any> {
+  id: string;
+  payload: T;
+}
+
+export type TTagStore = { [key: string]: ITag };
--- a/ts/smartsocket.classes.smartsocket.ts
+++ b/ts/smartsocket.classes.smartsocket.ts
@ -1,68 +1,136 @@
-import * as plugins from "./smartsocket.plugins";
-import * as helpers from "./smartsocket.helpers";
+import * as plugins from './smartsocket.plugins.js';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';

 // classes
-import { Objectmap } from "lik";
-import {SocketRole} from "./smartsocket.classes.socketrole";
-import {SocketFunction} from "./smartsocket.classes.socketfunction";
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
+import {
+  ISocketFunctionCallDataRequest,
+  SocketFunction,
+  ISocketFunctionCallDataResponse,
+} from './smartsocket.classes.socketfunction.js';
+import { SocketRequest } from './smartsocket.classes.socketrequest.js';
+import { SocketServer } from './smartsocket.classes.socketserver.js';

-
-export interface ISocketObject {
-    alias?:string;
-    authenticated: boolean
-    role?:string,
-    socket: SocketIO.Socket,
-};
+import { logger } from './smartsocket.logging.js';

 export interface ISmartsocketConstructorOptions {
-    port: number;
-
-};
+  alias: string;
+  port?: number;
+}

 export class Smartsocket {
-    options:ISmartsocketConstructorOptions
-    io: SocketIO.Server;
-    openSockets = new Objectmap();
-    registeredRoles = new Objectmap();
-    constructor(optionsArg: ISmartsocketConstructorOptions) {
-        this.options = optionsArg;
-    };
+  /**
+   * a unique id to detect server restarts
+   */
+  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 socketFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
+  public socketRequests = new plugins.lik.ObjectMap<SocketRequest<any>>();

-    /**
-     * the standard handler for new socket connections
-     */
-    private _handleSocket(socket) {
-        let socketObject: ISocketObject = {
-            socket: socket,
-            authenticated: false
-        };
-        plugins.beautylog.log("Socket connected. Trying to authenticate...")
-        this.openSockets.add(socketObject);
-        helpers.authenticateSocket(socketObject)
-            .then();
-    }
+  public eventSubject = plugins.smartrx.rxjs.Subject;

-    registerFunctions(socketRoleArg:SocketRole){
-        this.registeredRoles.add(socketRoleArg);
-    };
+  private socketServer = new SocketServer(this);

+  constructor(optionsArg: ISmartsocketConstructorOptions) {
+    this.options = optionsArg;
+    this.alias = plugins.isounique.uni(this.options.alias);
+  }

-    /**
-     * starts listening to incling sockets:
-     */
+  public async setExternalServer(serverType: 'smartexpress', serverArg: any) {
+    await this.socketServer.setExternalServer(serverType, serverArg);
+  }

-    startServer = () => {
-        this.io = plugins.socketIo(this.options.port);
-        this.io.on('connection', (socketArg) => {
-            this._handleSocket(socketArg);
-        });
-    }
-    closeServer = () => {
-        this.openSockets.forEach((socketObjectArg: ISocketObject) => {
-            plugins.beautylog.log(`disconnect socket with >>alias ${socketObjectArg.alias}`);
-            socketObjectArg.socket.disconnect();
-        });
-        this.openSockets.wipe();
-        this.io.close();
-    }
-}
+  /**
+   * starts smartsocket
+   */
+  public async start() {
+    const socketIoModule = await this.smartenv.getSafeNodeModule('socket.io');
+    this.io = new socketIoModule.Server(await this.socketServer.getServerForSocketIo(), {
+      cors: {
+        allowedHeaders: '*',
+        methods: '*',
+        origin: '*',
+      }
+    });
+    await this.socketServer.start();
+    this.io.on('connection', (socketArg) => {
+      this._handleSocketConnection(socketArg);
+    });
+  }
+
+  /**
+   * stops smartsocket
+   */
+  public async stop() {
+    await plugins.smartdelay.delayFor(1000);
+    this.socketConnections.forEach((socketObjectArg: SocketConnection) => {
+      if (socketObjectArg) {
+        logger.log(
+          'info',
+          `disconnecting socket with >>alias ${socketObjectArg.alias} due to server stop...`
+        );
+        socketObjectArg.disconnect();
+      }
+    });
+    this.socketConnections.wipe();
+    this.io.close();
+
+    // stop the corresponging server
+    this.socketServer.stop();
+  }
+
+  // communication
+
+  /**
+   * allows call to specific client.
+   */
+  public async clientCall<T extends plugins.typedrequestInterfaces.ITypedRequest>(
+    functionNameArg: T['method'],
+    dataArg: T['request'],
+    targetSocketConnectionArg: SocketConnection
+  ): Promise<T['response']> {
+    const socketRequest = new SocketRequest<T>(this, {
+      funcCallData: {
+        funcDataArg: dataArg,
+        funcName: functionNameArg,
+      },
+      originSocketConnection: targetSocketConnectionArg,
+      shortId: plugins.isounique.uni(),
+      side: 'requesting',
+    });
+    const response: ISocketFunctionCallDataResponse<T> = await socketRequest.dispatch();
+    const result = response.funcDataArg;
+    return result;
+  }
+
+  public addSocketFunction(socketFunction: SocketFunction<any>) {
+    this.socketFunctions.add(socketFunction);
+  }
+
+  /**
+   * the standard handler for new socket connections
+   */
+  private async _handleSocketConnection(socketArg: pluginsTyped.socketIo.Socket) {
+    const socketConnection: SocketConnection = new SocketConnection({
+      alias: undefined,
+      authenticated: false,
+      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');
+  }
+}
--- a/ts/smartsocket.classes.smartsocketclient.ts
+++ b/ts/smartsocket.classes.smartsocketclient.ts
@ -1,15 +1,266 @@
-import * as plugins from "./smartsocket.plugins"
+import * as plugins from './smartsocket.plugins.js';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';
+import * as interfaces from './interfaces/index.js';
+
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
+import {
+  ISocketFunctionCallDataRequest,
+  SocketFunction,
+} from './smartsocket.classes.socketfunction.js';
+import { ISocketRequestDataObject, SocketRequest } from './smartsocket.classes.socketrequest.js';
+import { logger } from './smartsocket.logging.js';

 /**
 * interface for class SmartsocketClient
 */
 export interface ISmartsocketClientOptions {
-    port:number;
-    url:string;
+  port: number;
+  url: string;
+  alias: string; // an alias makes it easier to identify this client in a multo client environment
+  autoReconnect?: boolean;
 }

 export class SmartsocketClient {
-    constructor(){
+  // a unique id
+  public shortId = plugins.isounique.uni();

+  // the shortId of the remote we connect to
+  public remoteShortId: string = null;
+
+  public alias: string;
+  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>>();
+
+  // 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.autoReconnect = optionsArg.autoReconnect;
+  }
+
+  public addSocketFunction(socketFunction: SocketFunction<any>) {
+    this.socketFunctions.add(socketFunction);
+  }
+
+  /**
+   * connect the client to the server
+   */
+  public async connect() {
+    const done = plugins.smartpromise.defer();
+    const smartenvInstance = new plugins.smartenv.Smartenv();
+    const socketIoClient: any = await smartenvInstance.getEnvAwareModule({
+      nodeModuleName: 'socket.io-client',
+      webUrlArg: 'https://cdn.jsdelivr.net/npm/socket.io-client@4/dist/socket.io.js',
+      getFunction: () => {
+        const socketIoBrowserModule = (globalThis as any).io;
+        // console.log('loaded socket.io for browser');
+        return socketIoBrowserModule;
+      },
+    });
+    // console.log(socketIoClient);
+    logger.log('info', 'trying to connect...');
+    const socketUrl = `${this.serverUrl}:${this.serverPort}`;
+    this.socketConnection = new SocketConnection({
+      alias: this.alias,
+      authenticated: false,
+      side: 'client',
+      smartsocketHost: this,
+      socket: await socketIoClient
+        .connect(socketUrl, {
+          multiplex: true,
+          rememberUpgrade: true,
+          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(true);
+    });
+
+    // authentication flow
+    this.socketConnection.socket.on('requestAuth', (dataArg: interfaces.IRequestAuthPayload) => {
+      timer.reset();
+      logger.log('info', `server ${dataArg.serverAlias} requested authentication`);
+
+      // lets register the authenticated event
+      this.socketConnection.socket.on('authenticated', async () => {
+        this.remoteShortId = dataArg.serverAlias;
+        logger.log('info', 'client is authenticated');
+        this.socketConnection.authenticated = true;
+        await this.socketConnection.listenToFunctionRequests();
+      });
+
+      this.socketConnection.socket.on('serverFullyReactive', async () => {
+        // lets take care of retagging
+        const oldTagStore = this.tagStore;
+        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;
+          }
+        );
+
+        for (const tag of Object.keys(oldTagStore)) {
+          await this.addTag(oldTagStore[tag]);
+        }
+        this.updateStatus('connected');
+        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 () => {});
+
+    // handle disconnection and errors
+    this.socketConnection.socket.on('disconnect', async () => {
+      await this.disconnect(true);
+    });
+
+    this.socketConnection.socket.on('reconnect_failed', async () => {
+      await this.disconnect(true);
+    });
+    this.socketConnection.socket.on('connect_error', async () => {
+      await this.disconnect(true);
+    });
+    return done.promise;
+  }
+
+  private disconnectRunning = false;
+
+  /**
+   * disconnect from the server
+   */
+  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 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;
+
+    if (this.autoReconnect && useAutoReconnectSetting && this.eventStatus !== 'connecting') {
+      this.updateStatus('connecting');
+      console.log('debounced reconnect!');
+      await plugins.smartdelay.delayForRandom(10000, 20000);
+      this.disconnectRunning = false;
+      await this.connect();
+    } else {
+      this.disconnectRunning = false;
+    }
+  }
+
+  /**
+   * stops the client completely
+   */
+  public async stop() {
+    this.autoReconnect = false;
+    await this.disconnect();
+  }
+
+  /**
+   * 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.isounique.uni(),
+      funcCallData: {
+        funcName: functionNameArg,
+        funcDataArg: dataArg,
+      },
+    });
+    const response = await socketRequest.dispatch();
+    const result = response.funcDataArg;
+    return result;
+  }
+
+  private updateStatus(statusArg: interfaces.TConnectionStatus) {
+    if (this.eventStatus !== statusArg) {
+      this.eventSubject.next(statusArg);
+    }
+    this.eventStatus = statusArg;
+  }
+}
--- a/ts/smartsocket.classes.socketconnection.ts
+++ b/ts/smartsocket.classes.socketconnection.ts
@ -0,0 +1,224 @@
+import * as plugins from './smartsocket.plugins.js';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';
+import * as interfaces from './interfaces/index.js';
+
+// import classes
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
+import { SocketFunction } from './smartsocket.classes.socketfunction.js';
+import { SocketRequest, ISocketRequestDataObject } from './smartsocket.classes.socketrequest.js';
+
+// socket.io
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient.js';
+import { logger } from './smartsocket.logging.js';
+
+// export interfaces
+
+/**
+ * defines is a SocketConnection is server or client side. Important for mesh setups.
+ */
+export type TSocketConnectionSide = 'server' | 'client';
+
+/**
+ * interface for constructor of class SocketConnection
+ */
+export interface ISocketConnectionConstructorOptions {
+  alias: string;
+  authenticated: boolean;
+  side: TSocketConnectionSide;
+  smartsocketHost: Smartsocket | SmartsocketClient;
+  socket: pluginsTyped.socketIo.Socket | pluginsTyped.socketIoClient.Socket;
+}
+
+/**
+ * interface for authentication data
+ */
+export interface ISocketConnectionAuthenticationObject {
+  alias: string;
+}
+
+// export classes
+export let allSocketConnections = new plugins.lik.ObjectMap<SocketConnection>();
+
+/**
+ * class SocketConnection represents a websocket connection
+ */
+export class SocketConnection {
+  public alias: string;
+  public side: TSocketConnectionSide;
+  public authenticated: boolean = false;
+  public smartsocketRef: Smartsocket | SmartsocketClient;
+  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.side = optionsArg.side;
+    this.smartsocketRef = optionsArg.smartsocketHost;
+    this.socket = optionsArg.socket;
+
+    // standard behaviour that is always true
+    allSocketConnections.add(this);
+
+    // 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`
+      );
+      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 --------------------------
+
+  /**
+   * authenticate the socket
+   */
+  public authenticate() {
+    const done = plugins.smartpromise.defer();
+    this.socket.on('dataAuth', async (dataArg: ISocketConnectionAuthenticationObject) => {
+      logger.log('info', 'received authentication data...');
+      this.socket.removeAllListeners('dataAuth');
+      if (dataArg.alias) {
+        // TODO: authenticate password
+        this.alias = dataArg.alias;
+        this.authenticated = true;
+        this.socket.emit('authenticated');
+        logger.log('ok', `socket with >>alias ${this.alias} is authenticated!`);
+        done.resolve(this);
+      } else {
+        this.authenticated = false;
+        await this.disconnect();
+        done.reject('a socket tried to connect, but could not authenticated.');
+      }
+    });
+    const requestAuthPayload: interfaces.IRequestAuthPayload = {
+      serverAlias: this.smartsocketRef.alias,
+    };
+    this.socket.emit('requestAuth', requestAuthPayload);
+    return done.promise;
+  }
+
+  // listening -------------------------------
+
+  /**
+   * listen to function requests
+   */
+  public listenToFunctionRequests() {
+    const done = plugins.smartpromise.defer();
+    if (this.authenticated) {
+      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.smartsocketRef.socketFunctions.findSync((socketFunctionArg) => {
+            return socketFunctionArg.name === dataArg.funcCallData.funcName;
+          });
+        if (referencedFunction) {
+          // logger.log('ok', 'function in access scope');
+          const localSocketRequest = new SocketRequest(this.smartsocketRef, {
+            side: 'responding',
+            originSocketConnection: this,
+            shortId: dataArg.shortId,
+            funcCallData: dataArg.funcCallData,
+          });
+          localSocketRequest.createResponse(); // takes care of creating response and sending it back
+        } else {
+          logger.log('warn', 'function not existent or out of access scope');
+        }
+      });
+      this.socket.on('functionResponse', (dataArg: ISocketRequestDataObject<any>) => {
+        // logger.log('info', `received response for request with id ${dataArg.shortId}`);
+        const targetSocketRequest = SocketRequest.getSocketRequestById(
+          this.smartsocketRef,
+          dataArg.shortId
+        );
+        targetSocketRequest.handleResponse(dataArg);
+      });
+
+      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';
+      logger.log('error', errMessage);
+      done.reject(errMessage);
+    }
+    return done.promise;
+  }
+
+  // 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;
+  }
+}
--- a/ts/smartsocket.classes.socketfunction.ts
+++ b/ts/smartsocket.classes.socketfunction.ts
@ -1,24 +1,93 @@
-import * as plugins from "./smartsocket.plugins";
+import * as plugins from './smartsocket.plugins.js';

 // import classes
-import { Stringmap } from "lik";
-import { SocketRole } from "./smartsocket.classes.socketrole";
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient.js';

+// export interfaces

+/**
+ * interface of the contructor options of class SocketFunction
+ */
+export interface ISocketFunctionConstructorOptions<
+  T extends plugins.typedrequestInterfaces.ITypedRequest
+> {
+  funcName: T['method'];
+  funcDef: TFuncDef<T>;
+}

-export interface SocketFunctionOptions {
-    name: string;
-    func: any;
-    roles: 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 ISocketFunctionCallDataRequest<
+  T extends plugins.typedrequestInterfaces.ITypedRequest
+> {
+  funcName: T['method'];
+  funcDataArg: T['request'];
+}

-export class SocketFunction {
-    name: string;
-    func: any;
-    roles: SocketRole[];
-    constructor(optionsArg: SocketFunctionOptions) {
-        this.name = optionsArg.name;
-        this.func = optionsArg.func;
-        this.roles = optionsArg.roles;
-    };
-}
+/**
+ * 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 type TFuncDef<T extends plugins.typedrequestInterfaces.ITypedRequest> = (
+  dataArg: T['request'],
+  connectionArg: SocketConnection
+) => PromiseLike<T['response']>;
+
+// export classes
+
+/**
+ * class that respresents a function that can be transparently called using a SocketConnection
+ */
+export class SocketFunction<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+  // STATIC
+  public static getSocketFunctionByName<Q extends plugins.typedrequestInterfaces.ITypedRequest>(
+    smartsocketRefArg: Smartsocket | SmartsocketClient,
+    functionNameArg: string
+  ): SocketFunction<Q> {
+    return smartsocketRefArg.socketFunctions.findSync((socketFunctionArg) => {
+      return socketFunctionArg.name === functionNameArg;
+    });
+  }
+
+  // INSTANCE
+  public name: string;
+  public funcDef: TFuncDef<T>;
+
+  /**
+   * the constructor for SocketFunction
+   */
+  constructor(optionsArg: ISocketFunctionConstructorOptions<T>) {
+    this.name = optionsArg.funcName;
+    this.funcDef = optionsArg.funcDef;
+  }
+
+  /**
+   * invokes the function of this SocketFunction
+   */
+  public async invoke(
+    dataArg: ISocketFunctionCallDataRequest<T>,
+    socketConnectionArg: SocketConnection
+  ): Promise<ISocketFunctionCallDataResponse<T>> {
+    if (dataArg.funcName === this.name) {
+      const funcResponseData: ISocketFunctionCallDataResponse<T> = {
+        funcName: this.name,
+        funcDataArg: await this.funcDef(dataArg.funcDataArg, socketConnectionArg),
+      };
+      return funcResponseData;
+    } else {
+      throw new Error("SocketFunction.name does not match the data argument's .name!");
+    }
+  }
+}
--- a/ts/smartsocket.classes.socketrequest.ts
+++ b/ts/smartsocket.classes.socketrequest.ts
@ -0,0 +1,126 @@
+import * as plugins from './smartsocket.plugins.js';
+
+// import interfaces
+import {
+  SocketFunction,
+  ISocketFunctionCallDataRequest,
+  ISocketFunctionCallDataResponse,
+} from './smartsocket.classes.socketfunction.js';
+
+// import classes
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
+import { logger } from './smartsocket.logging.js';
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient.js';
+
+// export interfaces
+export type TSocketRequestStatus = 'new' | 'pending' | 'finished';
+export type TSocketRequestSide = 'requesting' | 'responding';
+
+/**
+ * interface of constructor of class SocketRequest
+ */
+export interface ISocketRequestConstructorOptions<
+  T extends plugins.typedrequestInterfaces.ITypedRequest
+> {
+  side: TSocketRequestSide;
+  originSocketConnection: SocketConnection;
+  shortId: string;
+  funcCallData?: ISocketFunctionCallDataRequest<T>;
+}
+
+/**
+ * request object that is sent initially and may or may not receive a response
+ */
+export interface ISocketRequestDataObject<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+  funcCallData: ISocketFunctionCallDataRequest<T> | ISocketFunctionCallDataResponse<T>;
+  shortId: string;
+  responseTimeout?: number;
+}
+
+// export classes
+export class SocketRequest<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+  // STATIC
+  public static getSocketRequestById(
+    smartsocketRef: Smartsocket | SmartsocketClient,
+    shortIdArg: string
+  ): SocketRequest<any> {
+    return smartsocketRef.socketRequests.findSync((socketRequestArg) => {
+      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;
+    this.smartsocketRef.socketRequests.add(this);
+  }
+
+  // requesting --------------------------
+
+  /**
+   * dispatches a socketrequest from the requesting to the receiving side
+   */
+  public dispatch(): Promise<ISocketFunctionCallDataResponse<T>> {
+    const requestData: ISocketRequestDataObject<T> = {
+      funcCallData: this.funcCallData,
+      shortId: this.shortid,
+    };
+    this.originSocketConnection.socket.emit('function', requestData);
+    return this.done.promise;
+  }
+
+  /**
+   * handles the response that is received by the requesting side
+   */
+  public async handleResponse(responseDataArg: ISocketRequestDataObject<T>) {
+    // logger.log('info', 'handling response!');
+    this.done.resolve(responseDataArg.funcCallData);
+    this.smartsocketRef.socketRequests.remove(this);
+  }
+
+  // responding --------------------------
+
+  /**
+   * creates the response on the responding side
+   */
+  public async createResponse(): Promise<void> {
+    const targetSocketFunction: SocketFunction<T> = SocketFunction.getSocketFunctionByName(
+      this.smartsocketRef,
+      this.funcCallData.funcName
+    );
+
+    if (!targetSocketFunction) {
+      logger.log('error', `There is no SocketFunction defined for ${this.funcCallData.funcName}`);
+      return;
+    }
+    // logger.log('info', `invoking ${targetSocketFunction.name}`);
+    targetSocketFunction
+      .invoke(this.funcCallData, this.originSocketConnection)
+      .then((resultData) => {
+        // logger.log('info', 'got resultData. Sending it to requesting party.');
+        const responseData: ISocketRequestDataObject<T> = {
+          funcCallData: resultData,
+          shortId: this.shortid,
+        };
+        this.originSocketConnection.socket.emit('functionResponse', responseData);
+        this.smartsocketRef.socketRequests.remove(this);
+      });
+  }
+}
--- a/ts/smartsocket.classes.socketrole.ts
+++ b/ts/smartsocket.classes.socketrole.ts
@ -1,25 +0,0 @@
-import * as plugins from "./smartsocket.plugins";
-
-// import classes
-import { Stringmap } from "lik";
-
-/**
- * interface for class SocketRole
- */
-export interface SocketRoleOptions {
-    name:string;
-    passwordHash:string;
-}
-
-
-/**
- * A socketrole defines access to certain routines.
- */
-export class SocketRole {
-    name:string;
-    passwordHash:string;
-    constructor(optionsArg:SocketRoleOptions){
-        this.name = optionsArg.name;
-        this.passwordHash = optionsArg.passwordHash;
-    }
-}
--- a/ts/smartsocket.classes.socketserver.ts
+++ b/ts/smartsocket.classes.socketserver.ts
@ -0,0 +1,94 @@
+import * as plugins from './smartsocket.plugins.js';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';
+
+// used in case no other server is supplied
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
+import { logger } from './smartsocket.logging.js';
+
+/**
+ * class socketServer
+ * handles the attachment of socketIo to whatever server is in play
+ */
+export class SocketServer {
+  private smartsocket: Smartsocket;
+  private httpServerDeferred: plugins.smartpromise.Deferred<any>;
+  private httpServer: pluginsTyped.http.Server | pluginsTyped.https.Server;
+
+  /**
+   * wether httpServer is standalone
+   */
+  private standaloneServer = false;
+
+  constructor(smartSocketInstance: Smartsocket) {
+    this.smartsocket = smartSocketInstance;
+  }
+
+  /**
+   * starts the server with another server
+   * also works with an express style server
+   */
+  public async setExternalServer(
+    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 async getServerForSocketIo() {
+    if (this.httpServerDeferred) {
+      await this.httpServerDeferred.promise;
+    }
+    if (this.httpServer) {
+      return this.httpServer;
+    } else {
+      const httpModule = await this.smartsocket.smartenv.getSafeNodeModule('http');
+      this.httpServer = new httpModule.Server();
+      this.standaloneServer = true;
+      return this.httpServer;
+    }
+  }
+
+  /**
+   * starts listening to incoming sockets:
+   */
+  public async start() {
+    const done = plugins.smartpromise.defer();
+
+    // handle http servers
+    // in case an external server has been set "this.standaloneServer" should be false
+    if (this.httpServer && this.standaloneServer) {
+      if (!this.smartsocket.options.port) {
+        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, () => {
+        logger.log(
+          'success',
+          `Server started in standalone mode on ${this.smartsocket.options.port}`
+        );
+        done.resolve();
+      });
+    } else {
+      done.resolve();
+    }
+
+    // nothing else to do if express server is set
+    await done.promise;
+    return;
+  }
+
+  /**
+   * closes the server
+   */
+  public async stop() {
+    if (this.httpServer) {
+      this.httpServer.close();
+    }
+  }
+}
--- a/ts/smartsocket.helpers.ts
+++ b/ts/smartsocket.helpers.ts
@ -1,31 +0,0 @@
-import * as plugins from "./smartsocket.plugins";
-
-// interfaces
-import {ISocketObject} from "./smartsocket.classes.smartsocket";
-
-
-
-
-/**
- * authenticate a socket
- */
-export let authenticateSocket = (socketObjectArg: ISocketObject) => {
-    let done = plugins.q.defer();
-    socketObjectArg.socket.on("dataAuth", dataArg => {
-        plugins.beautylog.log("received authentication data. now hashing and comparing...");
-        socketObjectArg.socket.removeListener("dataAuth", () => { });
-        if((true)){ // TODO: authenticate password
-            socketObjectArg.alias = dataArg.alias 
-            socketObjectArg.authenticated = true;
-            socketObjectArg.role = dataArg.role;
-            socketObjectArg.socket.emit("authenticated");
-            plugins.beautylog.ok(`socket with >>alias ${socketObjectArg.alias} >>role ${socketObjectArg.role} is authenticated!`)
-            done.resolve(socketObjectArg);
-        } else {
-            socketObjectArg.socket.disconnect();
-            done.reject("not authenticated");
-        };
-    });
-    socketObjectArg.socket.emit("requestAuth");
-    return done.promise;
-};
--- a/ts/smartsocket.logging.ts
+++ b/ts/smartsocket.logging.ts
@ -0,0 +1,3 @@
+import * as plugins from './smartsocket.plugins.js';
+
+export const logger = new plugins.smartlog.ConsoleLog();
--- a/ts/smartsocket.plugins.ts
+++ b/ts/smartsocket.plugins.ts
@ -1,7 +1,29 @@
-import "typings-global";
-export import beautylog = require("beautylog");
-export import lik  = require("lik");
-export import q = require("q");
-export import socketIo = require("socket.io");
-export import socketIoClient = require("socket.io-client");
-export import taskbuffer = require("taskbuffer");
+// 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 smartjson from '@pushrocks/smartjson';
+import * as smartlog from '@pushrocks/smartlog';
+import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smarttime from '@pushrocks/smarttime';
+import * as smartrx from '@pushrocks/smartrx';
+
+export {
+  isohash,
+  isounique,
+  lik,
+  smartenv,
+  smartjson,
+  smartlog,
+  smartdelay,
+  smartpromise,
+  smarttime,
+  smartrx,
+};
--- a/ts/smartsocket.pluginstyped.ts
+++ b/ts/smartsocket.pluginstyped.ts
@ -0,0 +1,23 @@
+// node native
+import type * as http from 'http';
+import type * as https from 'https';
+
+export { http, https };
+
+// pushrocks scope
+import type * as smartexpress from '@pushrocks/smartexpress';
+
+export { smartexpress };
+
+// third party scope
+import type { Socket as ServerSocket, Server as ServerServer } from 'socket.io';
+import type { Socket as ClientSocket, connect as ClientIo } from 'socket.io-client';
+
+export namespace socketIo {
+  export type Socket = ServerSocket;
+  export type Server = ServerServer;
+}
+export namespace socketIoClient {
+  export type Socket = ClientSocket;
+  export type connect = typeof ClientIo;
+}
--- a/tsconfig.json
+++ b/tsconfig.json
@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "nodenext",
+    "esModuleInterop": true
+  }
+}
Author	SHA1	Message	Date
Philipp Kunz	4fc09af779	2.0.17	2023-03-29 16:07:54 +02:00
Philipp Kunz	f73d973383	fix(core): update	2023-03-29 16:07:54 +02:00
Philipp Kunz	d87a942ab3	2.0.16	2023-03-20 18:51:02 +01:00
Philipp Kunz	60e8657467	fix(core): update	2023-03-20 18:51:02 +01:00
Philipp Kunz	5215be946e	2.0.15	2023-02-07 12:32:48 +01:00
Philipp Kunz	b9c67666fa	fix(core): update	2023-02-07 12:32:48 +01:00
Philipp Kunz	4b0fb073e6	2.0.14	2022-12-29 13:28:11 +01:00
Philipp Kunz	fc458b6827	fix(core): update	2022-12-29 13:28:11 +01:00
Philipp Kunz	f27b9f8143	2.0.13	2022-12-29 11:18:16 +01:00
Philipp Kunz	38058aba57	fix(core): update	2022-12-29 11:18:15 +01:00
Philipp Kunz	ba38dae64f	2.0.12	2022-12-28 19:51:09 +01:00
Philipp Kunz	69e862a6cf	fix(core): update	2022-12-28 19:51:09 +01:00
Philipp Kunz	4562ac355b	2.0.11	2022-12-28 14:02:15 +01:00
Philipp Kunz	b029dc191e	fix(core): update	2022-12-28 14:02:14 +01:00
Philipp Kunz	2640275d04	2.0.10	2022-12-28 13:52:17 +01:00
Philipp Kunz	7bbcc91300	fix(core): update	2022-12-28 13:52:16 +01:00
Philipp Kunz	da39d52975	2.0.9	2022-12-28 13:51:41 +01:00
Philipp Kunz	307469312f	fix(core): update	2022-12-28 13:51:40 +01:00
Philipp Kunz	0f3ff2b611	2.0.8	2022-12-28 13:49:03 +01:00
Philipp Kunz	bce82d49b6	fix(core): update	2022-12-28 13:49:03 +01:00
Philipp Kunz	0b10913995	2.0.7	2022-08-01 15:00:07 +02:00
Philipp Kunz	7048585702	fix(core): update	2022-08-01 15:00:06 +02:00
Philipp Kunz	92697bad82	2.0.6	2022-03-25 00:30:31 +01:00
Philipp Kunz	e1475a3342	fix(core): update	2022-03-25 00:30:31 +01:00
Philipp Kunz	e3c58e7fc0	2.0.5	2022-03-24 23:29:04 +01:00
Philipp Kunz	32d60fff0d	fix(core): update	2022-03-24 23:29:03 +01:00
Philipp Kunz	f33b64d625	2.0.4	2022-03-24 21:56:26 +01:00
Philipp Kunz	6ee70ecafa	2.0.3	2022-03-24 20:26:03 +01:00
Philipp Kunz	6f3700adc0	2.0.2	2022-03-24 20:17:04 +01:00
Philipp Kunz	3648f12358	fix(core): update	2022-03-24 20:17:04 +01:00
Philipp Kunz	c239eaa9d5	2.0.1	2022-03-24 12:52:29 +01:00
Philipp Kunz	75bd7a9175	fix(core): update	2022-03-24 12:52:28 +01:00
Philipp Kunz	be9b47e73b	2.0.0	2022-03-14 22:40:56 +01:00
Philipp Kunz	966d953aff	BREAKING CHANGE(switch to esm): update	2022-03-14 22:40:55 +01:00
Philipp Kunz	7f73664970	1.2.22	2022-01-20 18:38:18 +01:00
Philipp Kunz	71452a293f	fix(core): update	2022-01-20 18:38:17 +01:00
Philipp Kunz	c5e60d804a	1.2.21	2022-01-20 18:33:47 +01:00
Philipp Kunz	c5d52013e6	fix(core): update	2022-01-20 18:33:46 +01:00
Philipp Kunz	64195e4c78	1.2.20	2022-01-20 17:14:12 +01:00
Philipp Kunz	01b5b3dc1a	fix(core): update	2022-01-20 17:14:11 +01:00
Philipp Kunz	b34d7faec2	1.2.19	2022-01-20 16:50:26 +01:00
Philipp Kunz	7c98e19988	fix(core): update	2022-01-20 16:50:25 +01:00
Philipp Kunz	608669ec44	1.2.18	2022-01-19 19:52:16 +01:00
Philipp Kunz	a7b14cd383	fix(core): update	2022-01-19 19:52:14 +01:00
Philipp Kunz	21dc933302	1.2.17	2022-01-19 19:05:45 +01:00
Philipp Kunz	4e7455fa26	fix(core): update	2022-01-19 19:05:44 +01:00
Philipp Kunz	c424d589ea	1.2.16	2022-01-19 18:36:14 +01:00
Philipp Kunz	9435796333	fix(core): update	2022-01-19 18:36:13 +01:00
Philipp Kunz	12d7310b90	1.2.15	2022-01-19 18:06:41 +01:00
Philipp Kunz	9fc4db1e35	fix(core): update	2022-01-19 18:06:39 +01:00
Philipp Kunz	895464115e	1.2.14	2022-01-19 16:37:46 +01:00
Philipp Kunz	00f22f9651	fix(core): update	2022-01-19 16:37:45 +01:00
Philipp Kunz	278b35c9c5	1.2.13	2022-01-19 15:34:53 +01:00
Philipp Kunz	da78da27e5	fix(core): update	2022-01-19 15:34:52 +01:00
Philipp Kunz	a8aeeaaa6c	1.2.12	2022-01-19 08:05:08 +01:00
Philipp Kunz	f9f6975b87	fix(core): update	2022-01-19 08:05:06 +01:00
Philipp Kunz	b9a6f1d5b0	1.2.11	2022-01-19 07:01:59 +01:00
Philipp Kunz	489ad9284b	fix(core): update	2022-01-19 07:01:58 +01:00
Philipp Kunz	6fdf0d9955	1.2.10	2022-01-18 18:54:30 +01:00
Philipp Kunz	499a1893f9	fix(core): update	2022-01-18 18:54:29 +01:00
Philipp Kunz	2754447aae	1.2.9	2022-01-18 17:10:47 +01:00
Philipp Kunz	544277cb8a	fix(core): update	2022-01-18 17:10:46 +01:00
Phil Kunz	9a23960d21	1.2.8	2021-02-01 22:36:38 +00:00
Phil Kunz	23cca6cce3	fix(core): update	2021-02-01 22:36:37 +00:00
Phil Kunz	2a9e58cc35	1.2.7	2021-01-28 12:39:32 +00:00
Phil Kunz	7d6a9921b5	fix(core): update	2021-01-28 12:39:31 +00:00
Phil Kunz	3ee46a31f7	1.2.6	2021-01-28 01:39:24 +00:00
Phil Kunz	d72310ce10	fix(core): update	2021-01-28 01:39:23 +00:00
Phil Kunz	1e14166ddb	1.2.5	2021-01-28 01:31:43 +00:00
Phil Kunz	be38e91548	fix(core): update	2021-01-28 01:31:42 +00:00
Phil Kunz	6c2057b119	1.2.4	2021-01-28 01:30:28 +00:00
Phil Kunz	08d7224016	fix(core): update	2021-01-28 01:30:27 +00:00
Phil Kunz	bfa3330eb6	1.2.3	2021-01-23 06:03:55 +00:00
Phil Kunz	644fa2a49d	fix(core): update	2021-01-23 06:03:54 +00:00
Phil Kunz	c0dad3a977	1.2.2	2021-01-23 05:50:02 +00:00
Phil Kunz	a921033cc4	fix(core): update	2021-01-23 05:50:02 +00:00
Phil Kunz	21e4712b04	1.2.1	2021-01-23 04:12:56 +00:00
Phil Kunz	df43bc2974	fix(core): update	2021-01-23 04:12:55 +00:00
Phil Kunz	564988185d	1.2.0	2020-12-26 18:06:23 +00:00
Phil Kunz	8442f3570f	feat(SmartsocketClient): socket client can now be stopped with .stop() addiditionally to .reconnect(), which will still try to re	2020-12-26 18:06:22 +00:00
Phil Kunz	196357c878	1.1.71	2020-12-26 17:43:20 +00:00
Phil Kunz	bc187b7e41	fix(core): update	2020-12-26 17:43:19 +00:00
Phil Kunz	0e54bf889f	1.1.70	2020-12-22 00:19:00 +00:00
Phil Kunz	4c211bc82e	fix(test): use @pushrocks/isohash instead of @pushrocks/smarthash in tests	2020-12-22 00:18:59 +00:00
Phil Kunz	a1be281670	1.1.69	2020-12-16 02:20:28 +00:00
Phil Kunz	1a44d2027c	fix(core): update	2020-12-16 02:20:28 +00:00
Phil Kunz	4bf5456a1d	1.1.68	2020-12-16 01:38:58 +00:00
Phil Kunz	57c748657a	fix(core): update	2020-12-16 01:38:57 +00:00
Phil Kunz	15df24bf68	1.1.67	2020-09-30 00:20:54 +00:00
Phil Kunz	ca7470eedf	fix(core): update	2020-09-30 00:20:53 +00:00
Phil Kunz	38f017934c	1.1.66	2020-09-29 19:43:10 +00:00
Phil Kunz	1980824540	fix(core): update	2020-09-29 19:43:10 +00:00
Phil Kunz	09dec2071e	1.1.65	2020-09-29 19:42:38 +00:00
Phil Kunz	a1443deafe	fix(core): update	2020-09-29 19:42:38 +00:00
Phil Kunz	9eac5ad336	1.1.64	2020-09-29 19:37:49 +00:00
Phil Kunz	cf607a79d5	fix(core): update	2020-09-29 19:37:49 +00:00
Phil Kunz	8426c976bf	1.1.63	2020-09-29 18:58:10 +00:00
Phil Kunz	1086065000	fix(core): update	2020-09-29 18:58:09 +00:00
Phil Kunz	72196ec383	1.1.62	2020-09-29 17:21:08 +00:00
Phil Kunz	c6ad490a6f	fix(core): update	2020-09-29 17:21:08 +00:00
Phil Kunz	a40a83f0bf	1.1.61	2020-09-29 08:35:27 +00:00
Phil Kunz	82fa029d05	fix(core): update	2020-09-29 08:35:26 +00:00
Phil Kunz	0d76e7f577	1.1.60	2020-09-24 18:04:12 +00:00
Phil Kunz	57e6f058be	fix(core): update	2020-09-24 18:04:11 +00:00
Phil Kunz	b0bf9d7c95	1.1.59	2020-09-24 18:03:02 +00:00
Phil Kunz	1fbc76ef30	fix(core): update	2020-09-24 18:03:01 +00:00
Phil Kunz	424d9cca91	1.1.58	2019-11-08 18:48:39 +01:00
Phil Kunz	d712270946	fix(core): update	2019-11-08 18:48:39 +01:00
Phil Kunz	f98c797ad8	1.1.57	2019-11-08 18:41:09 +01:00
Phil Kunz	a23e7349be	fix(core): update	2019-11-08 18:41:08 +01:00
Phil Kunz	c390881a4e	1.1.56	2019-11-08 17:31:04 +01:00
Phil Kunz	5e64f4ca25	fix(core): update	2019-11-08 17:31:04 +01:00
Phil Kunz	765bc73197	1.1.55	2019-11-08 17:11:41 +01:00
Phil Kunz	105acaf97b	fix(core): update	2019-11-08 17:11:41 +01:00
Phil Kunz	5139136af4	1.1.54	2019-11-07 00:26:47 +01:00
Phil Kunz	bcc4ce9a87	fix(core): update	2019-11-07 00:26:47 +01:00
Phil Kunz	20e7584eb9	1.1.53	2019-11-03 20:23:15 +01:00
Phil Kunz	59cbc343cc	fix(core): update	2019-11-03 20:23:15 +01:00
Phil Kunz	75aa1f6f0d	1.1.52	2019-11-03 19:17:26 +01:00
Phil Kunz	3f073ab9b3	fix(core): update	2019-11-03 19:17:26 +01:00
Phil Kunz	08c1618ea8	1.1.51	2019-11-03 18:33:46 +01:00
Phil Kunz	eb181fa2f6	fix(core): update	2019-11-03 18:33:46 +01:00
Phil Kunz	c901ab75d3	1.1.50	2019-11-03 16:48:35 +01:00
Phil Kunz	075c59ed2c	fix(core): update	2019-11-03 16:48:35 +01:00
Phil Kunz	8d358dd93d	1.1.49	2019-09-10 00:21:48 +02:00
Phil Kunz	e576d6058a	fix(core): update	2019-09-10 00:21:47 +02:00
Phil Kunz	6546da2394	1.1.48	2019-09-09 23:58:32 +02:00
Phil Kunz	29597daba1	fix(core): update	2019-09-09 23:58:32 +02:00
Phil Kunz	c8b647d2fd	1.1.47	2019-09-09 16:20:43 +02:00
Phil Kunz	1fa4aca049	fix(core): update	2019-09-09 16:20:43 +02:00
Phil Kunz	2d4695de22	1.1.46	2019-09-01 18:07:53 +02:00
Phil Kunz	a3f4dcbc2a	fix(core): update	2019-09-01 18:07:52 +02:00
Phil Kunz	d6e81288b4	1.1.45	2019-08-13 15:58:08 +02:00
Phil Kunz	c441d89596	fix(core): update	2019-08-13 15:58:08 +02:00
Phil Kunz	85b69e487a	1.1.44	2019-08-13 11:36:32 +02:00
Phil Kunz	0d94ed9345	fix(core): update	2019-08-13 11:36:31 +02:00
Phil Kunz	e188b18016	1.1.43	2019-08-13 09:37:23 +02:00
Phil Kunz	33c0fa3746	fix(core): update	2019-08-13 09:37:23 +02:00
Phil Kunz	52be1415ee	1.1.42	2019-08-12 22:46:57 +02:00
Phil Kunz	e75d5eabdb	fix(core): update	2019-08-12 22:46:57 +02:00
Phil Kunz	fb99848df1	1.1.41	2019-08-12 22:45:58 +02:00
Phil Kunz	1bd39d0755	fix(core): update	2019-08-12 22:45:58 +02:00
Phil Kunz	d24c5f628c	1.1.40	2019-08-12 22:31:41 +02:00
Phil Kunz	33fbabdd72	fix(core): update	2019-08-12 22:31:40 +02:00
Phil Kunz	9d26fff986	1.1.39	2019-08-12 18:16:26 +02:00
Phil Kunz	41151e5436	fix(core): update	2019-08-12 18:16:25 +02:00
Phil Kunz	109c5197f3	1.1.38	2019-06-07 08:40:24 +02:00
Phil Kunz	c3d47c1f50	fix(core): update	2019-06-07 08:40:24 +02:00
Phil Kunz	1b45fb45e9	1.1.37	2019-06-06 23:11:03 +02:00
Phil Kunz	c22adc9b57	fix(core): update	2019-06-06 23:11:03 +02:00
Phil Kunz	35e87306dd	1.1.36	2019-05-02 11:46:36 +02:00
Phil Kunz	1b20aa5992	fix(core): update	2019-05-02 11:46:36 +02:00
Phil Kunz	a63f14da47	1.1.35	2019-04-26 17:35:15 +02:00
Phil Kunz	86cf94c5dc	fix(core): update	2019-04-26 17:35:15 +02:00
Phil Kunz	0d39d6f237	1.1.34	2019-04-24 18:30:57 +02:00
Phil Kunz	1856ad5cfc	fix(core): update	2019-04-24 18:30:56 +02:00
Phil Kunz	b5dab810e8	1.1.33	2019-04-24 17:57:17 +02:00
Phil Kunz	f145b85b1c	fix(core): update	2019-04-24 17:57:16 +02:00
Phil Kunz	a8c647c5c7	1.1.32	2019-04-24 17:17:36 +02:00
Phil Kunz	22472e0adf	fix(core): update	2019-04-24 17:17:36 +02:00
Phil Kunz	333ddb4d9c	1.1.31	2019-04-24 17:10:52 +02:00
Phil Kunz	126f020bf8	fix(core): update	2019-04-24 17:10:51 +02:00
Phil Kunz	7677b1bb48	1.1.30	2019-04-24 16:09:01 +02:00
Phil Kunz	114379c5b3	fix(core): update	2019-04-24 16:09:01 +02:00
Phil Kunz	79ae7d2039	1.1.29	2019-04-24 15:47:29 +02:00
Phil Kunz	d2cb6a3045	fix(core): update	2019-04-24 15:47:28 +02:00
Phil Kunz	963619b2ed	1.1.28	2019-04-23 17:28:46 +02:00
Phil Kunz	976abaaed7	fix(core): update	2019-04-23 17:28:46 +02:00
Phil Kunz	ef322c32ac	1.1.27	2019-01-31 02:32:52 +01:00
Phil Kunz	475911a968	fix(build): now building with tsbuild	2019-01-31 02:32:52 +01:00
Phil Kunz	5530e29da4	1.1.26	2019-01-31 00:54:40 +01:00
Phil Kunz	5f1d2c83c6	fix(core): update	2019-01-31 00:54:39 +01:00
Phil Kunz	b84dd36885	1.1.25	2019-01-31 00:46:42 +01:00
Phil Kunz	c2d64ba39a	fix(readme): update	2019-01-31 00:46:42 +01:00
Phil Kunz	85a5d7cdaf	1.1.24	2019-01-30 10:55:52 +01:00
Phil Kunz	69380a2dbc	fix(npmextra): adjust access level	2019-01-30 10:55:51 +01:00
Phil Kunz	fc292d83b9	1.1.23	2019-01-30 10:55:17 +01:00
Phil Kunz	b29961df95	fix(scope): switch to @pushrocks	2019-01-30 10:55:16 +01:00
Phil Kunz	f774a82ad5	1.1.22	2019-01-30 03:21:15 +01:00
Phil Kunz	5a45f4750b	fix(package.json): private setting	2019-01-30 03:21:14 +01:00
Phil Kunz	fc6227ef96	1.1.21	2019-01-30 03:15:22 +01:00
Phil Kunz	873aba3e0b	fix(snyk): add .snyk file	2019-01-30 03:15:21 +01:00
Phil Kunz	f9bed9da8a	1.1.20	2019-01-30 03:14:03 +01:00
Phil Kunz	d296064bfa	fix(structure): update to latest standards	2019-01-30 03:14:02 +01:00
Phil Kunz	1b0922759a	1.1.19	2018-03-19 10:00:14 +01:00
Phil Kunz	aef4f9c591	now working as expected	2018-03-19 10:00:11 +01:00
Phil Kunz	abf546eec3	1.1.18	2018-03-18 17:50:39 +01:00
Phil Kunz	483cb38175	start transitioning to better SocketFunction handling	2018-03-18 17:50:37 +01:00
Phil Kunz	b2bd66a6a6	1.1.17	2018-03-18 16:40:42 +01:00
Phil Kunz	cfc3e8788d	add @types/node	2018-03-18 16:40:40 +01:00
Phil Kunz	23c14c032c	1.1.16	2018-03-17 17:52:36 +01:00
Phil Kunz	c92dae809f	format README	2018-03-17 17:52:31 +01:00
Phil Kunz	7200464e4b	1.1.15	2018-03-17 17:52:07 +01:00
Phil Kunz	eaa97f0598	update readme	2018-03-17 17:52:01 +01:00
Phil Kunz	cde8270313	1.1.14	2018-03-17 17:18:59 +01:00
Phil Kunz	1b073ac8f6	update readme	2018-03-17 17:18:53 +01:00
Phil Kunz	3f3857df1e	1.1.13	2018-03-15 02:29:44 +01:00
Phil Kunz	02e17a52c3	update to latest standards	2018-03-15 02:29:40 +01:00
Phil Kunz	287c2a73c5	1.1.12	2017-10-09 16:46:24 +02:00
Phil Kunz	dea3746bb0	allow setting of specific server	2017-10-09 10:40:59 +02:00
Phil Kunz	fc2a55bb0d	fix not ending error correctly	2017-10-09 10:28:18 +02:00
Phil Kunz	99eca912d3	1.1.11	2017-10-09 03:06:14 +02:00
Phil Kunz	0b6929af8f	update to newest version	2017-10-09 03:06:09 +02:00
Phil Kunz	0aa073f2a7	1.1.10	2017-07-15 23:16:26 +02:00
Phil Kunz	7170e58457	update smartsocket class to use standard class method definition	2017-07-15 23:16:22 +02:00
Phil Kunz	cccee35f2c	1.1.9	2017-07-07 22:38:14 +02:00
Phil Kunz	118ec84ec5	update docs	2017-07-07 22:38:10 +02:00
Phil Kunz	dd31eea263	update tests	2017-07-07 22:10:03 +02:00
Phil Kunz	477429143d	1.1.8	2017-07-07 22:03:22 +02:00
Phil Kunz	ea6fa14133	remove taskbuffer	2017-07-07 22:03:18 +02:00
Phil Kunz	02065e36a6	update to latest standards	2017-07-07 22:02:19 +02:00
PhilKunz	f34358db81	update README	2016-09-26 16:59:06 +02:00
PhilKunz	fddf54b2b1	1.1.7	2016-09-26 00:28:45 +02:00
PhilKunz	e1dbdc1a15	improve README	2016-09-26 00:28:39 +02:00
PhilKunz	f3031a1d4e	1.1.6	2016-09-26 00:23:28 +02:00
PhilKunz	47ca497d48	improve README	2016-09-26 00:23:17 +02:00
PhilKunz	c7e3c4537b	1.1.5	2016-09-05 00:34:13 +02:00
PhilKunz	62b36ab859	fix scoping of socket roles	2016-09-05 00:34:09 +02:00
PhilKunz	4563aade16	small syntax fix	2016-09-04 22:20:33 +02:00
PhilKunz	47596bfa59	1.1.4	2016-09-03 16:21:00 +02:00
PhilKunz	6543d60019	added docs	2016-09-03 16:03:57 +02:00
PhilKunz	f0aba45cec	1.1.3	2016-09-03 00:41:52 +02:00
PhilKunz	f327fa2784	updated dependencies and exported socketConnection	2016-09-03 00:41:49 +02:00
philkunz	983b4672fd	1.1.2	2016-08-16 04:48:47 +02:00
philkunz	c81a41b365	now authenticating sockets by checking the password hash	2016-08-16 04:48:42 +02:00
philkunz	abe4d22226	1.1.1	2016-08-15 03:47:36 +02:00
philkunz	87cc238345	update README	2016-08-15 03:47:32 +02:00
philkunz	475cd12904	1.1.0	2016-08-15 02:36:24 +02:00
philkunz	84f33fa447	now working in both directions so mesh setups work.	2016-08-15 02:36:17 +02:00
philkunz	180ae23c9a	1.0.7	2016-08-15 01:38:38 +02:00
philkunz	7f0fff0bf4	updated tests. Data now flows correctly between socket endpoints	2016-08-15 01:38:28 +02:00
philkunz	24310b6709	1.0.6	2016-08-14 22:18:09 +02:00
philkunz	bd8697ac6e	reconnect is now working	2016-08-14 22:17:55 +02:00
philkunz	7b2b2bd151	updated structure	2016-08-14 03:25:26 +02:00
PhilKunz	8dfc39be75	update tests	2016-08-12 05:57:32 +02:00
PhilKunz	ab2196fd5f	update tests: starting with updating tests to use both server and client side to mimic operation	2016-08-12 05:56:40 +02:00
PhilKunz	3afede95fc	now handling responses	2016-08-12 05:17:13 +02:00
PhilKunz	da510eb87a	more structure updates	2016-08-12 03:22:36 +02:00
PhilKunz	cb3d7f4d7b	update structure	2016-08-12 01:32:57 +02:00
PhilKunz	19a883c641	structure update	2016-08-09 23:37:25 +02:00
PhilKunz	1f8e1fc7cb	some heavy internal refactoring	2016-08-09 18:22:30 +02:00
PhilKunz	5109964247	some more logic request/response abstraction to make transparent function calls happen	2016-08-09 16:33:56 +02:00
PhilKunz	f670cae1f8	1.0.5	2016-08-09 11:42:27 +02:00
PhilKunz	fee54dfb95	add some more logic	2016-08-09 11:42:21 +02:00
PhilKunz	8d58e0b2f3	update structure	2016-08-08 18:20:00 +02:00
PhilKunz	fc530ba37e	1.0.4	2016-08-07 19:15:10 +02:00
PhilKunz	62abfda156	improve README	2016-08-07 19:15:05 +02:00