v3.0.0

- Updated test files to use new testing library and reduced test cycles for efficiency.
- Removed dependency on smartexpress and integrated direct WebSocket handling.
- Enhanced Smartsocket and SmartsocketClient classes to support new message types and authentication flow.
- Implemented a new message interface for structured communication between client and server.
- Added external server support for smartserve with appropriate WebSocket hooks.
- Improved connection management and error handling in SocketConnection and SocketRequest classes.
- Cleaned up code and removed deprecated socket.io references in favor of native WebSocket.

.gitea/workflows/default_nottags.yaml

@@ -0,0 +1,66 @@
+name: Default (not tags)
+
+on:
+  push:
+    tags-ignore:
+      - '**'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install pnpm and npmci
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+
+      - name: Run npm prepare
+        run: npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build

.gitea/workflows/default_tags.yaml

@@ -0,0 +1,124 @@
+name: Default (tags)
+
+on:
+  push:
+    tags:
+      - '*'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build
+
+  release:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Release
+        run: |
+          npmci node install stable
+          npmci npm publish
+
+  metadata:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Code quality
+        run: |
+          npmci command npm install -g typescript
+          npmci npm install
+
+      - name: Trigger
+        run: npmci trigger
+
+      - name: Build docs and upload artifacts
+        run: |
+          npmci node install stable
+          npmci npm install
+          pnpm install -g @git.zone/tsdoc
+          npmci command tsdoc
+        continue-on-error: true

.gitignore

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

.gitlab-ci.yml

@@ -1,150 +0,0 @@
-# gitzone standard
-image: hosttoday/ht-docker-node:npmci
-
-cache:
-  paths:
-  - .npmci_cache/
-  key: "$CI_BUILD_STAGE"
-
-stages:
-- security
-- test
-- release
-- metadata
-
-# ====================
-# security stage
-# ====================
-mirror:
-  stage: security
-  script:
-  - npmci git mirror
-  tags:
-  - docker
-  - notpriv
-
-snyk:
-  stage: security
-  script:
-    - npmci npm prepare
-    - npmci command npm install -g snyk
-    - npmci command npm install --ignore-scripts
-    - npmci command snyk test
-  tags:
-  - docker
-  - notpriv
-
-sast:
-  stage: security
-  image: registry.gitlab.com/hosttoday/ht-docker-dbase:npmci
-  variables:
-    DOCKER_DRIVER: overlay2
-  allow_failure: true
-  services:
-    - docker:stable-dind
-  script:
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command npm run build
-    - export SP_VERSION=$(echo "$CI_SERVER_VERSION" | sed 's/^\([0-9]*\)\.\([0-9]*\).*/\1-\2-stable/')
-    - docker run
-        --env SAST_CONFIDENCE_LEVEL="${SAST_CONFIDENCE_LEVEL:-3}"
-        --volume "$PWD:/code"
-        --volume /var/run/docker.sock:/var/run/docker.sock
-        "registry.gitlab.com/gitlab-org/security-products/sast:$SP_VERSION" /app/bin/run /code
-  artifacts:
-    reports:
-      sast: gl-sast-report.json
-  tags:
-  - docker
-  - priv
-
-# ====================
-# test stage
-# ====================
-
-testLTS:
-  stage: test
-  script:
-  - npmci npm prepare
-  - npmci node install lts
-  - npmci npm install
-  - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - notpriv
-    
-testSTABLE:
-  stage: test
-  script:
-  - npmci npm prepare
-  - npmci node install stable
-  - npmci npm install
-  - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - notpriv
-
-release:
-  stage: release
-  script:
-  - npmci node install stable
-  - npmci npm publish
-  only:
-  - tags
-  tags:
-  - docker
-  - notpriv
-
-# ====================
-# metadata stage
-# ====================
-codequality:
-  stage: metadata
-  image: docker:stable
-  allow_failure: true
-  services:
-    - docker:stable-dind
-  script:
-    - export SP_VERSION=$(echo "$CI_SERVER_VERSION" | sed 's/^\([0-9]*\)\.\([0-9]*\).*/\1-\2-stable/')
-    - docker run
-        --env SOURCE_CODE="$PWD"
-        --volume "$PWD":/code
-        --volume /var/run/docker.sock:/var/run/docker.sock
-        "registry.gitlab.com/gitlab-org/security-products/codequality:$SP_VERSION" /code
-  artifacts:
-    paths: [codeclimate.json]
-  tags:
-  - docker
-  - priv
-
-trigger:
-  stage: metadata
-  script:
-  - npmci trigger
-  only:
-  - tags
-  tags:
-  - docker
-  - notpriv
-
-pages:
-  image: hosttoday/ht-docker-node:npmci
-  stage: metadata
-  script:
-    - npmci command npm install -g typedoc typescript
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command typedoc --module "commonjs" --target "ES2016" --out public/ ts/
-  tags:
-    - docker
-    - notpriv
-  only:
-    - tags
-  artifacts:
-    expire_in: 1 week
-    paths:
-    - public
-  allow_failure: true

.snyk

@@ -1,4 +0,0 @@
-# Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
-version: v1.13.3
-ignore: {}
-patch: {}

.vscode/launch.json

@@ -0,0 +1,11 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "command": "npm test",
+      "name": "Run npm test",
+      "request": "launch",
+      "type": "node-terminal"
+    }
+  ]
+}

.vscode/settings.json

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

README.md

@@ -1,116 +0,0 @@
-# smartsocket
-
-easy and secure websocket communication, TypeScript ready
-
-## Availabililty
-
-[![npm](https://pushrocks.gitlab.io/assets/repo-button-npm.svg)](https://www.npmjs.com/package/smartsocket)
-[![git](https://pushrocks.gitlab.io/assets/repo-button-git.svg)](https://GitLab.com/pushrocks/smartsocket)
-[![git](https://pushrocks.gitlab.io/assets/repo-button-mirror.svg)](https://github.com/pushrocks/smartsocket)
-[![docs](https://pushrocks.gitlab.io/assets/repo-button-docs.svg)](https://pushrocks.gitlab.io/smartsocket/)
-
-## Status for master
-
-[![build status](https://GitLab.com/pushrocks/smartsocket/badges/master/build.svg)](https://GitLab.com/pushrocks/smartsocket/commits/master)
-[![coverage report](https://GitLab.com/pushrocks/smartsocket/badges/master/coverage.svg)](https://GitLab.com/pushrocks/smartsocket/commits/master)
-[![npm downloads per month](https://img.shields.io/npm/dm/smartsocket.svg)](https://www.npmjs.com/package/smartsocket)
-[![Dependency Status](https://david-dm.org/pushrocks/smartsocket.svg)](https://david-dm.org/pushrocks/smartsocket)
-[![bitHound Dependencies](https://www.bithound.io/github/pushrocks/smartsocket/badges/dependencies.svg)](https://www.bithound.io/github/pushrocks/smartsocket/master/dependencies/npm)
-[![bitHound Code](https://www.bithound.io/github/pushrocks/smartsocket/badges/code.svg)](https://www.bithound.io/github/pushrocks/smartsocket)
-[![TypeScript](https://img.shields.io/badge/TypeScript-2.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
-[![node](https://img.shields.io/badge/node->=%206.x.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
-[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com/)
-
-## Usage
-
-Use TypeScript for best in class instellisense.
-
-Under the hood we use socket.io and shortid for managed data exchange.
-
-### Serverside
-
-```typescript
-import * as smartsocket from 'smartsocket';
-import * as q from q; // q is a promise library
-
-// The "Smartsocket" listens on a port and can receive new "SocketConnection" requests.
-let mySmartsocket = new smartsocket.Smartsocket({
-  port: 3000 // the port smartsocket will listen on
-});
-
-// optional:
-// run this with anothoer existing server like express
-declare var someExpressServer; // read the express docs about how express actually works
-mySmartsocket.setServer(someExpressServer);
-
-// A "SocketRole" can be referenced by "SocketFunction"s.
-// All "SocketRequest"s carry authentication data for a specific "SocketRole".
-// "SocketFunction"s know which "SocketRole"s are allowed to execute them
-let mySocketRole = new smartsocket.SocketRole({
-  name: 'someRoleName',
-  passwordHash: 'someHashedString'
-});
-
-// A "SocketFunction" executes a referenced function and passes in any data of the corresponding "SocketRequest".
-// The referenced function must return a promise and resolve with data of type any.
-// Any "SocketRequest" carries a unique identifier. If the referenced function's promise resolved any passed on argument will be returned to the requesting party
-let testSocketFunction1 = new smartsocket.SocketFunction({
-  funcName: 'testSocketFunction1',
-  funcDef: data => {
-    console.log('testSocketFunction1 executed successfully!');
-  },
-  allowedRoles: [mySocketRole] // all roles that have access to a specific function
-});
-
-// A "Smartsocket" exposes a .clientCall() that gets
-// 1. the name of the "SocketFunction" on the client side
-// 2. the data to pass in
-// 3. And a target "SocketConnection" (there can be multiple connections at once)
-// any unique id association is done internally
-mySmartsocket.clientCall('restart', data, someTargetConnection).then(responseData => {});
-```
-
-#### Client side
-
-```typescript
-import * as smartsocket from 'smartsocket';
-
-// A "SmartsocketClient" is different from a "Smartsocket" in that it doesn't expose any public address.
-// Thus any new "SocketConnection"s must be innitiated from a "SmartsocketClient".
-let testSmartsocketClient = new smartsocket.SmartsocketClient({
-  port: testConfig.port,
-  url: 'http://localhost',
-  password: 'testPassword',
-  alias: 'testClient1',
-  role: 'testRole1'
-});
-
-// You can .connect() and .disconnect() from a "Smartsocket"
-testSmartsocketClient.connect().then(() => {
-  done();
-});
-
-// The client can also specify "SocketFunction"s. It can also specify "SocketRole"s in case a client connects to multiple servers at once
-let testSocketFunction2 = new smartsocket.SocketFunction({
-  funcName: 'testSocketFunction2',
-  funcDef: data => {}, // the function to execute, has to return promise
-  allowedRoles: []
-});
-
-// A "SmartsocketClient" can call functions on the serverside using .serverCall() analog to the "Smartsocket"'s .clientCall method.
-mySmartsocketClient.serverCall('function', functionCallData).then(functionResponseData => {
-  // the functionResponseData comes from the server... awesome, right?
-});
-```
-
-> **NOTE:**  
-> you can easily chain dependent requests on either the server or client side with promises.  
-> `data` is always a js object that you can design for your specific needs.  
-> It supports buffers for large binary data network exchange.
-
-For further information read the linked docs at the top of this README.
-
-> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
-> | By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy.html)
-
-[![repo-footer](https://pushrocks.gitlab.io/assets/repo-footer.svg)](https://push.rocks)

changelog.md

@@ -0,0 +1,112 @@
+# Changelog
+
+## 2025-12-03 - 3.0.0 - BREAKING CHANGE(smartsocket)
+Replace setExternalServer with hooks-based SmartServe integration and refactor SocketServer to support standalone and hooks modes
+
+- Remove setExternalServer API and add getSmartserveWebSocketHooks on Smartsocket to provide SmartServe-compatible websocket hooks.
+- SocketServer.start now becomes a no-op when no port is provided (hooks mode). When a port is set, it starts a standalone HTTP + ws server as before.
+- Introduce an adapter (createWsLikeFromPeer) to adapt SmartServe peers to a WebSocket-like interface and route onMessage/onClose/onError via the adapter.
+- Dispatch smartserve messages through the adapter: text/binary handling for onMessage, and dispatchClose/dispatchError for close/error events.
+- Update tests: add smartserve integration test (test.smartserve.ts), adjust tagging test cleanup to stop client and delay before exit, remove outdated expressserver test.
+
+## 2025-03-10 - 2.1.0 - feat(SmartsocketClient)
+Improve client reconnection logic with exponential backoff and jitter; update socket.io and @types/node dependencies
+
+- Bump engine.io from 6.5.4 to 6.6.4, socket.io and socket.io-client from 4.7.5 to 4.8.1
+- Bump @types/node from ^20.12.7 to ^22.13.10
+- Add new optional reconnection parameters (maxRetries, initialBackoffDelay, maxBackoffDelay) to SmartsocketClient options
+- Implement exponential backoff with jitter for auto-reconnect and reset reconnection state on successful connection
+
+## 2024-05-29 - 2.0.27 - docs
+update description
+
+## 2024-04-26 to 2024-03-30 - 2.0.26 … 2.0.24 - core & configuration
+A series of internal fixes and configuration tweaks.
+- fix(core): update
+- update tsconfig
+- update npmextra.json: githost
+
+## 2023-09-10 to 2023-07-21 - 2.0.23 … 2.0.20 - core
+Multiple minor core fixes were applied in rapid succession.
+- fix(core): update
+
+## 2023-07-21 to 2023-03-20 - 2.0.19 … 2.0.15 - core
+Routine internal updates addressing core functionality.
+- fix(core): update
+
+## 2023-02-07 to 2022-03-24 - 2.0.14 … 2.0.0 - core
+Further minor core updates were rolled out over several versions.
+- fix(core): update
+
+## 2022-03-14 - 1.2.22 - esm
+A breaking change was introduced to switch the module system.
+- BREAKING CHANGE(switch to esm): update
+
+## 2022-01-20 to 2021-01-23 - 1.2.21 … 1.2.0 - core
+A range of minor core fixes.
+- fix(core): update
+
+## 2020-12-26 - 1.1.71 - SmartsocketClient
+New functionality in the socket client was added.
+- feat(SmartsocketClient): socket client can now be stopped with .stop() in addition to .reconnect()
+
+## 2020-12-26 to 2020-09-24 - 1.1.70 … 1.1.58 - core & test
+A group of updates addressing both core mechanics and tests.
+- fix(core): update
+- fix(test): use @pushrocks/isohash instead of @pushrocks/smarthash
+
+## 2019-11-08 to 2019-04-23 - 1.1.57 … 1.1.27 - core
+Numerous versions in this period included only internal core fixes.
+- fix(core): update
+
+## 2019-01-31 to 2019-01-30 - 1.1.26 … 1.1.19 - build, docs & configuration
+Updates went beyond the core, affecting build tooling and package metadata.
+- fix(build): now building with tsbuild
+- fix(readme): update
+- fix(npmextra): adjust access level
+- fix(scope): switch to @pushrocks
+- fix(package.json): private setting
+- fix(snyk): add .snyk file
+- fix(structure): update to latest standards
+
+## 2018-03-19 to 2018-03-15 - 1.1.18 … 1.1.12 - core & docs
+Several improvements touching both functionality and documentation.
+- now working as expected
+- start transitioning to better SocketFunction handling
+- add @types/node
+- format and update README
+- update to latest standards
+
+## 2017-10-09 to 2017-07-07 - 1.1.11 … 1.1.07 - core & docs
+Updates in this range improved both the internal mechanics and the developer‐facing materials.
+- allow setting of specific server
+- fix not ending error correctly
+- update to newest version
+- update docs and tests
+- remove taskbuffer
+- update to latest standards
+
+## 2016-09-25 to 2016-09-03 - 1.1.6 … 1.1.3 - docs & core
+Minor improvements in documentation and code quality.
+- improve README
+- added docs
+- fix scoping of socket roles and perform small syntax fixes
+
+## 2016-09-02 to 2016-08-16 - 1.1.2 … 1.1.1 - dependencies & security
+Several housekeeping tasks to update dependencies and improve security.
+- updated dependencies and exported socketConnection
+- now authenticating sockets by checking the password hash
+
+## 2016-08-15 - 1.1.0 - docs
+A documentation update was published.
+- update README
+
+## 2016-08-15 - 1.0.7 - networking
+A key update made the socket client work bi-directionally, enabling mesh setups.
+- now working in both directions so mesh setups work
+
+## 2016-08-14 to 2016-08-07 - 1.0.6 … 1.0.0 - internal changes
+From the initial release onward, several internal improvements were introduced:
+- updated tests and structure
+- reworked reconnection logic and added a request/response abstraction for transparent function calls
+- initial release features with updated documentation and structure

dist/index.d.ts

@@ -1,5 +0,0 @@
-export * from './smartsocket.classes.smartsocket';
-export * from './smartsocket.classes.smartsocketclient';
-export * from './smartsocket.classes.socketfunction';
-export * from './smartsocket.classes.socketrole';
-export * from './smartsocket.classes.socketconnection';

dist/index.js

@@ -1,13 +0,0 @@
-"use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-// export main classes
-__export(require("./smartsocket.classes.smartsocket"));
-__export(require("./smartsocket.classes.smartsocketclient"));
-// export further classes and objects
-__export(require("./smartsocket.classes.socketfunction"));
-__export(require("./smartsocket.classes.socketrole"));
-__export(require("./smartsocket.classes.socketconnection"));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUVBLHNCQUFzQjtBQUN0Qix1REFBa0Q7QUFDbEQsNkRBQXdEO0FBRXhELHFDQUFxQztBQUNyQywwREFBcUQ7QUFDckQsc0RBQWlEO0FBQ2pELDREQUF1RCJ9

dist/smartsocket.classes.smartsocket.d.ts

@@ -1,37 +0,0 @@
-/// <reference types="socket.io" />
-import * as plugins from './smartsocket.plugins';
-import { SocketConnection } from './smartsocket.classes.socketconnection';
-import { SocketRole } from './smartsocket.classes.socketrole';
-import * as SocketIO from 'socket.io';
-export interface ISmartsocketConstructorOptions {
-    port: number;
-}
-export declare class Smartsocket {
-    options: ISmartsocketConstructorOptions;
-    io: SocketIO.Server;
-    openSockets: plugins.lik.Objectmap<SocketConnection>;
-    socketRoles: plugins.lik.Objectmap<SocketRole>;
-    private socketServer;
-    constructor(optionsArg: ISmartsocketConstructorOptions);
-    setExternalServer: (serverType: "express" | "http", serverArg: any) => Promise<void>;
-    /**
-     * starts smartsocket
-     */
-    start(): Promise<void>;
-    /**
-     * stops smartsocket
-     */
-    stop(): Promise<void>;
-    /**
-     * allows call to specific client.
-     */
-    clientCall(functionNameArg: string, dataArg: any, targetSocketConnectionArg: SocketConnection): Promise<{}>;
-    /**
-     * adds socketRoles
-     */
-    addSocketRoles(socketRolesArray: SocketRole[]): void;
-    /**
-     * the standard handler for new socket connections
-     */
-    private _handleSocketConnection(socketArg);
-}

dist/smartsocket.classes.smartsocket.js

@@ -1,111 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const plugins = require("./smartsocket.plugins");
-// classes
-const lik_1 = require("lik");
-const smartsocket_classes_socketconnection_1 = require("./smartsocket.classes.socketconnection");
-const smartsocket_classes_socketrequest_1 = require("./smartsocket.classes.socketrequest");
-const smartsocket_classes_socketserver_1 = require("./smartsocket.classes.socketserver");
-class Smartsocket {
-    constructor(optionsArg) {
-        this.openSockets = new lik_1.Objectmap();
-        this.socketRoles = new lik_1.Objectmap();
-        this.socketServer = new smartsocket_classes_socketserver_1.SocketServer(this);
-        // tslint:disable-next-line:member-ordering
-        this.setExternalServer = this.socketServer.setExternalServer;
-        this.options = optionsArg;
-    }
-    /**
-     * starts smartsocket
-     */
-    start() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.io = plugins.socketIo(this.socketServer.getServerForSocketIo());
-            yield this.socketServer.start();
-            this.io.on('connection', socketArg => {
-                this._handleSocketConnection(socketArg);
-            });
-        });
-    }
-    /**
-     * stops smartsocket
-     */
-    stop() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield plugins.smartdelay.delayFor(1000);
-            this.openSockets.forEach((socketObjectArg) => {
-                plugins.beautylog.log(`disconnect socket with >>alias ${socketObjectArg.alias}`);
-                socketObjectArg.socket.disconnect();
-            });
-            this.openSockets.wipe();
-            this.io.close();
-            // stop the corresponging server
-            this.socketServer.stop();
-        });
-    }
-    // communication
-    /**
-     * allows call to specific client.
-     */
-    clientCall(functionNameArg, dataArg, targetSocketConnectionArg) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const done = plugins.smartq.defer();
-            const socketRequest = new smartsocket_classes_socketrequest_1.SocketRequest({
-                funcCallData: {
-                    funcDataArg: dataArg,
-                    funcName: functionNameArg
-                },
-                originSocketConnection: targetSocketConnectionArg,
-                shortId: plugins.shortid.generate(),
-                side: 'requesting'
-            });
-            socketRequest.dispatch().then((dataArg) => {
-                done.resolve(dataArg.funcDataArg);
-            });
-            const result = yield done.promise;
-            return result;
-        });
-    }
-    /**
-     * adds socketRoles
-     */
-    addSocketRoles(socketRolesArray) {
-        for (const socketRole of socketRolesArray) {
-            this.socketRoles.add(socketRole);
-        }
-        return;
-    }
-    /**
-     * the standard handler for new socket connections
-     */
-    _handleSocketConnection(socketArg) {
-        const socketConnection = new smartsocket_classes_socketconnection_1.SocketConnection({
-            alias: undefined,
-            authenticated: false,
-            role: undefined,
-            side: 'server',
-            smartsocketHost: this,
-            socket: socketArg
-        });
-        plugins.beautylog.log('Socket connected. Trying to authenticate...');
-        this.openSockets.add(socketConnection);
-        socketConnection
-            .authenticate()
-            .then(() => {
-            return socketConnection.listenToFunctionRequests();
-        })
-            .catch(err => {
-            console.log(err);
-        });
-    }
-}
-exports.Smartsocket = Smartsocket;
-//# sourceMappingURL=data:application/json;base64,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

dist/smartsocket.classes.smartsocketclient.d.ts

@@ -1,26 +0,0 @@
-import { SocketConnection } from './smartsocket.classes.socketconnection';
-/**
- * interface for class SmartsocketClient
- */
-export interface ISmartsocketClientOptions {
-    port: number;
-    url: string;
-    alias: string;
-    role: string;
-    password: string;
-}
-export declare class SmartsocketClient {
-    alias: string;
-    role: string;
-    socketConnection: SocketConnection;
-    serverUrl: string;
-    serverPort: number;
-    serverPassword: string;
-    constructor(optionsArg: ISmartsocketClientOptions);
-    /**
-     * connect the client to the server
-     */
-    connect(): Promise<{}>;
-    disconnect(): Promise<{}>;
-    serverCall(functionNameArg: string, dataArg: any): Promise<{}>;
-}

dist/smartsocket.classes.smartsocketclient.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const plugins = require("./smartsocket.plugins");
-const smartsocket_classes_socketconnection_1 = require("./smartsocket.classes.socketconnection");
-const smartsocket_classes_socketrequest_1 = require("./smartsocket.classes.socketrequest");
-class SmartsocketClient {
-    constructor(optionsArg) {
-        this.alias = optionsArg.alias;
-        this.role = optionsArg.role;
-        this.serverUrl = optionsArg.url;
-        this.serverPort = optionsArg.port;
-        this.serverPassword = optionsArg.password;
-    }
-    /**
-     * connect the client to the server
-     */
-    connect() {
-        let done = plugins.smartq.defer();
-        plugins.beautylog.log('trying to connect...');
-        let socketUrl = `${this.serverUrl}:${this.serverPort}`;
-        this.socketConnection = new smartsocket_classes_socketconnection_1.SocketConnection({
-            alias: this.alias,
-            authenticated: false,
-            role: undefined,
-            side: 'client',
-            smartsocketHost: null,
-            socket: plugins.socketIoClient(socketUrl, { multiplex: false })
-        });
-        this.socketConnection.socket.on('requestAuth', () => {
-            console.log('server requested authentication');
-            this.socketConnection.socket.emit('dataAuth', {
-                role: this.role,
-                password: this.serverPassword,
-                alias: this.alias
-            });
-            this.socketConnection.socket.on('authenticated', () => {
-                console.log('client is authenticated');
-                this.socketConnection.authenticated = true;
-                this.socketConnection.listenToFunctionRequests();
-                done.resolve();
-            });
-        });
-        return done.promise;
-    }
-    disconnect() {
-        let done = plugins.smartq.defer();
-        this.socketConnection.socket.disconnect();
-        this.socketConnection = undefined;
-        plugins.beautylog.ok('disconnected!');
-        done.resolve();
-        return done.promise;
-    }
-    serverCall(functionNameArg, dataArg) {
-        let done = plugins.smartq.defer();
-        let socketRequest = new smartsocket_classes_socketrequest_1.SocketRequest({
-            side: 'requesting',
-            originSocketConnection: this.socketConnection,
-            shortId: plugins.shortid.generate(),
-            funcCallData: {
-                funcName: functionNameArg,
-                funcDataArg: dataArg
-            }
-        });
-        socketRequest.dispatch().then((dataArg) => {
-            done.resolve(dataArg.funcDataArg);
-        });
-        return done.promise;
-    }
-}
-exports.SmartsocketClient = SmartsocketClient;
-//# sourceMappingURL=data:application/json;base64,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

dist/smartsocket.classes.socketconnection.d.ts

@@ -1,50 +0,0 @@
-/// <reference types="socket.io" />
-/// <reference types="socket.io-client" />
-import * as plugins from './smartsocket.plugins';
-import { Smartsocket } from './smartsocket.classes.smartsocket';
-import { SocketRole } from './smartsocket.classes.socketrole';
-import * as SocketIO from 'socket.io';
-/**
- * defines is a SocketConnection is server or client side. Important for mesh setups.
- */
-export declare type TSocketConnectionSide = 'server' | 'client';
-/**
- * interface for constructor of class SocketConnection
- */
-export interface ISocketConnectionConstructorOptions {
-    alias: string;
-    authenticated: boolean;
-    role: SocketRole;
-    side: TSocketConnectionSide;
-    smartsocketHost: Smartsocket;
-    socket: SocketIO.Socket | SocketIOClient.Socket;
-}
-/**
- * interface for authentication data
- */
-export interface ISocketConnectionAuthenticationObject {
-    role: 'coreflowContainer';
-    password: 'somePassword';
-    alias: 'coreflow1';
-}
-export declare let allSocketConnections: plugins.lik.Objectmap<SocketConnection>;
-/**
- * class SocketConnection represents a websocket connection
- */
-export declare class SocketConnection {
-    alias: string;
-    side: TSocketConnectionSide;
-    authenticated: boolean;
-    role: SocketRole;
-    smartsocketHost: Smartsocket;
-    socket: any;
-    constructor(optionsArg: ISocketConnectionConstructorOptions);
-    /**
-     * authenticate the socket
-     */
-    authenticate(): Promise<{}>;
-    /**
-     * listen to function requests
-     */
-    listenToFunctionRequests(): Promise<{}>;
-}

dist/smartsocket.classes.socketconnection.js

@@ -1,100 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const plugins = require("./smartsocket.plugins");
-const helpers = require("./smartsocket.helpers");
-const lik_1 = require("lik");
-const smartsocket_classes_socketrequest_1 = require("./smartsocket.classes.socketrequest");
-// export classes
-exports.allSocketConnections = new lik_1.Objectmap();
-/**
- * class SocketConnection represents a websocket connection
- */
-class SocketConnection {
-    constructor(optionsArg) {
-        this.authenticated = false;
-        this.alias = optionsArg.alias;
-        this.authenticated = optionsArg.authenticated;
-        this.role = optionsArg.role;
-        this.side = optionsArg.side;
-        this.smartsocketHost = optionsArg.smartsocketHost;
-        this.socket = optionsArg.socket;
-        // standard behaviour that is always true
-        exports.allSocketConnections.add(this);
-        this.socket.on('disconnect', () => {
-            plugins.beautylog.info(`SocketConnection with >alias ${this.alias} on >side ${this.side} disconnected`);
-            this.socket.disconnect();
-            exports.allSocketConnections.remove(this);
-        });
-    }
-    // authenticating --------------------------
-    /**
-     * authenticate the socket
-     */
-    authenticate() {
-        let done = plugins.smartq.defer();
-        this.socket.on('dataAuth', (dataArg) => {
-            plugins.beautylog.log('received authentication data. now hashing and comparing...');
-            this.socket.removeListener('dataAuth', () => { });
-            if (helpers.checkPasswordForRole(dataArg, this.smartsocketHost)) {
-                // TODO: authenticate password
-                this.alias = dataArg.alias;
-                this.authenticated = true;
-                this.role = helpers.getSocketRoleByName(dataArg.role, this.smartsocketHost);
-                this.socket.emit('authenticated');
-                plugins.beautylog.ok(`socket with >>alias ${this.alias} >>role ${this.role} is authenticated!`);
-                done.resolve(this);
-            }
-            else {
-                this.authenticated = false;
-                this.socket.disconnect();
-                done.reject('not authenticated');
-            }
-        });
-        this.socket.emit('requestAuth');
-        return done.promise;
-    }
-    // listening -------------------------------
-    /**
-     * listen to function requests
-     */
-    listenToFunctionRequests() {
-        let done = plugins.smartq.defer();
-        if (this.authenticated) {
-            this.socket.on('function', (dataArg) => {
-                // check if requested function is available to the socket's scope
-                plugins.beautylog.log('function request received');
-                let referencedFunction = this.role.allowedFunctions.find(socketFunctionArg => {
-                    return socketFunctionArg.name === dataArg.funcCallData.funcName;
-                });
-                if (referencedFunction !== undefined) {
-                    plugins.beautylog.ok('function in access scope');
-                    let localSocketRequest = new smartsocket_classes_socketrequest_1.SocketRequest({
-                        side: 'responding',
-                        originSocketConnection: this,
-                        shortId: dataArg.shortId,
-                        funcCallData: dataArg.funcCallData
-                    });
-                    localSocketRequest.createResponse(); // takes care of creating response and sending it back
-                }
-                else {
-                    plugins.beautylog.warn('function not existent or out of access scope');
-                }
-            });
-            this.socket.on('functionResponse', (dataArg) => {
-                plugins.beautylog.info(`received response for request with id ${dataArg.shortId}`);
-                let targetSocketRequest = helpers.getSocketRequestById(dataArg.shortId);
-                targetSocketRequest.handleResponse(dataArg);
-            });
-            plugins.beautylog.log(`now listening to function requests for ${this.alias}`);
-            done.resolve(this);
-        }
-        else {
-            let errMessage;
-            plugins.beautylog.error(errMessage);
-            done.reject(errMessage);
-        }
-        return done.promise;
-    }
-}
-exports.SocketConnection = SocketConnection;
-//# sourceMappingURL=data:application/json;base64,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

dist/smartsocket.classes.socketfunction.d.ts

@@ -1,44 +0,0 @@
-import * as plugins from './smartsocket.plugins';
-import { SocketRole } from './smartsocket.classes.socketrole';
-/**
- * interface of the contructor options of class SocketFunction
- */
-export interface ISocketFunctionConstructorOptions {
-    funcName: string;
-    funcDef: any;
-    allowedRoles: SocketRole[];
-}
-/**
- * interface of the Socket Function call, in other words the object that routes a call to a function
- */
-export interface ISocketFunctionCall {
-    funcName: string;
-    funcDataArg: any;
-}
-/**
- * interface for function definition of SocketFunction
- */
-export interface IFuncDef {
-    (dataArg: any): PromiseLike<any>;
-}
-export declare let allSocketFunctions: plugins.lik.Objectmap<SocketFunction>;
-/**
- * class that respresents a function that can be transparently called using a SocketConnection
- */
-export declare class SocketFunction {
-    name: string;
-    funcDef: IFuncDef;
-    roles: SocketRole[];
-    /**
-     * the constructor for SocketFunction
-     */
-    constructor(optionsArg: ISocketFunctionConstructorOptions);
-    /**
-     * invokes the function of this SocketFunction
-     */
-    invoke(dataArg: ISocketFunctionCall): Promise<any>;
-    /**
-     * notifies a role about access to this SocketFunction
-     */
-    private _notifyRole(socketRoleArg);
-}

dist/smartsocket.classes.socketfunction.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const plugins = require("./smartsocket.plugins");
-// import classes
-const lik_1 = require("lik");
-// export objects
-exports.allSocketFunctions = new lik_1.Objectmap();
-// export classes
-/**
- * class that respresents a function that can be transparently called using a SocketConnection
- */
-class SocketFunction {
-    /**
-     * the constructor for SocketFunction
-     */
-    constructor(optionsArg) {
-        this.name = optionsArg.funcName;
-        this.funcDef = optionsArg.funcDef;
-        this.roles = optionsArg.allowedRoles;
-        for (let socketRoleArg of this.roles) {
-            this._notifyRole(socketRoleArg);
-        }
-        exports.allSocketFunctions.add(this); // map instance with Objectmap
-    }
-    /**
-     * invokes the function of this SocketFunction
-     */
-    invoke(dataArg) {
-        let done = plugins.smartq.defer();
-        if (dataArg.funcName === this.name) {
-            this.funcDef(dataArg.funcDataArg).then((resultData) => {
-                let funcResponseData = {
-                    funcName: this.name,
-                    funcDataArg: resultData
-                };
-                done.resolve(funcResponseData);
-            });
-        }
-        else {
-            throw new Error("SocketFunction.name does not match the data argument's .name!");
-        }
-        return done.promise;
-    }
-    /**
-     * notifies a role about access to this SocketFunction
-     */
-    _notifyRole(socketRoleArg) {
-        socketRoleArg.addSocketFunction(this);
-    }
-}
-exports.SocketFunction = SocketFunction;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRmdW5jdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmNsYXNzZXMuc29ja2V0ZnVuY3Rpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxpREFBaUQ7QUFFakQsaUJBQWlCO0FBQ2pCLDZCQUFnQztBQTZCaEMsaUJBQWlCO0FBQ04sUUFBQSxrQkFBa0IsR0FBRyxJQUFJLGVBQVMsRUFBa0IsQ0FBQztBQUVoRSxpQkFBaUI7QUFFakI7O0dBRUc7QUFDSDtJQUtFOztPQUVHO0lBQ0gsWUFBWSxVQUE2QztRQUN2RCxJQUFJLENBQUMsSUFBSSxHQUFHLFVBQVUsQ0FBQyxRQUFRLENBQUM7UUFDaEMsSUFBSSxDQUFDLE9BQU8sR0FBRyxVQUFVLENBQUMsT0FBTyxDQUFDO1FBQ2xDLElBQUksQ0FBQyxLQUFLLEdBQUcsVUFBVSxDQUFDLFlBQVksQ0FBQztRQUNyQyxHQUFHLENBQUMsQ0FBQyxJQUFJLGFBQWEsSUFBSSxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztZQUNyQyxJQUFJLENBQUMsV0FBVyxDQUFDLGFBQWEsQ0FBQyxDQUFDO1FBQ2xDLENBQUM7UUFDRCwwQkFBa0IsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyw4QkFBOEI7SUFDOUQsQ0FBQztJQUVEOztPQUVHO0lBQ0gsTUFBTSxDQUFDLE9BQTRCO1FBQ2pDLElBQUksSUFBSSxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDbEMsRUFBRSxDQUFDLENBQUMsT0FBTyxDQUFDLFFBQVEsS0FBSyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztZQUNuQyxJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxVQUFlLEVBQUUsRUFBRTtnQkFDekQsSUFBSSxnQkFBZ0IsR0FBd0I7b0JBQzFDLFFBQVEsRUFBRSxJQUFJLENBQUMsSUFBSTtvQkFDbkIsV0FBVyxFQUFFLFVBQVU7aUJBQ3hCLENBQUM7Z0JBQ0YsSUFBSSxDQUFDLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO1lBQ2pDLENBQUMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQztRQUFDLElBQUksQ0FBQyxDQUFDO1lBQ04sTUFBTSxJQUFJLEtBQUssQ0FBQywrREFBK0QsQ0FBQyxDQUFDO1FBQ25GLENBQUM7UUFDRCxNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQztJQUN0QixDQUFDO0lBRUQ7O09BRUc7SUFDSyxXQUFXLENBQUMsYUFBeUI7UUFDM0MsYUFBYSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3hDLENBQUM7Q0FDRjtBQTNDRCx3Q0EyQ0MifQ==

dist/smartsocket.classes.socketrequest.d.ts

@@ -1,44 +0,0 @@
-import * as plugins from './smartsocket.plugins';
-import { ISocketFunctionCall } from './smartsocket.classes.socketfunction';
-import { SocketConnection } from './smartsocket.classes.socketconnection';
-export declare type TSocketRequestStatus = 'new' | 'pending' | 'finished';
-export declare type TSocketRequestSide = 'requesting' | 'responding';
-/**
- * interface of constructor of class SocketRequest
- */
-export interface SocketRequestConstructorOptions {
-    side: TSocketRequestSide;
-    originSocketConnection: SocketConnection;
-    shortId: string;
-    funcCallData?: ISocketFunctionCall;
-}
-/**
- * request object that is sent initially and may or may not receive a response
- */
-export interface ISocketRequestDataObject {
-    funcCallData: ISocketFunctionCall;
-    shortId: string;
-    responseTimeout?: number;
-}
-export declare let allSocketRequests: plugins.lik.Objectmap<SocketRequest>;
-export declare class SocketRequest {
-    status: TSocketRequestStatus;
-    side: TSocketRequestSide;
-    shortid: string;
-    originSocketConnection: SocketConnection;
-    funcCallData: ISocketFunctionCall;
-    done: plugins.smartq.Deferred<{}>;
-    constructor(optionsArg: SocketRequestConstructorOptions);
-    /**
-     * dispatches a socketrequest from the requesting to the receiving side
-     */
-    dispatch(): Promise<{}>;
-    /**
-     * handles the response that is received by the requesting side
-     */
-    handleResponse(responseDataArg: ISocketRequestDataObject): void;
-    /**
-     * creates the response on the responding side
-     */
-    createResponse(): void;
-}

dist/smartsocket.classes.socketrequest.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const plugins = require("./smartsocket.plugins");
-const helpers = require("./smartsocket.helpers");
-// import classes
-const lik_1 = require("lik");
-// export objects
-exports.allSocketRequests = new lik_1.Objectmap();
-// export classes
-class SocketRequest {
-    constructor(optionsArg) {
-        this.status = 'new';
-        this.done = plugins.smartq.defer();
-        this.side = optionsArg.side;
-        this.shortid = optionsArg.shortId;
-        this.funcCallData = optionsArg.funcCallData;
-        this.originSocketConnection = optionsArg.originSocketConnection;
-        exports.allSocketRequests.add(this);
-    }
-    // requesting --------------------------
-    /**
-     * dispatches a socketrequest from the requesting to the receiving side
-     */
-    dispatch() {
-        let requestData = {
-            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
-     */
-    handleResponse(responseDataArg) {
-        plugins.beautylog.log('handling response!');
-        this.done.resolve(responseDataArg.funcCallData);
-        exports.allSocketRequests.remove(this);
-    }
-    // responding --------------------------
-    /**
-     * creates the response on the responding side
-     */
-    createResponse() {
-        let targetSocketFunction = helpers.getSocketFunctionByName(this.funcCallData.funcName);
-        plugins.beautylog.info(`invoking ${targetSocketFunction.name}`);
-        targetSocketFunction.invoke(this.funcCallData).then(resultData => {
-            plugins.beautylog.log('got resultData. Sending it to requesting party.');
-            let requestData = {
-                funcCallData: resultData,
-                shortId: this.shortid
-            };
-            this.originSocketConnection.socket.emit('functionResponse', requestData);
-            exports.allSocketRequests.remove(this);
-        });
-    }
-}
-exports.SocketRequest = SocketRequest;
-//# sourceMappingURL=data:application/json;base64,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

dist/smartsocket.classes.socketrole.d.ts

@@ -1,19 +0,0 @@
-import * as plugins from './smartsocket.plugins';
-import { SocketFunction } from './smartsocket.classes.socketfunction';
-/**
- * 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;
-    allowedFunctions: plugins.lik.Objectmap<SocketFunction>;
-    constructor(optionsArg: SocketRoleOptions);
-    addSocketFunction(socketFunctionArg: SocketFunction): void;
-}

dist/smartsocket.classes.socketrole.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// import classes
-const lik_1 = require("lik");
-/**
- * A socketrole defines access to certain routines.
- */
-class SocketRole {
-    constructor(optionsArg) {
-        this.allowedFunctions = new lik_1.Objectmap();
-        this.name = optionsArg.name;
-        this.passwordHash = optionsArg.passwordHash;
-    }
-    addSocketFunction(socketFunctionArg) {
-        this.allowedFunctions.add(socketFunctionArg);
-    }
-}
-exports.SocketRole = SocketRole;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRyb2xlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRzb2NrZXQuY2xhc3Nlcy5zb2NrZXRyb2xlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBRUEsaUJBQWlCO0FBQ2pCLDZCQUFnQztBQVdoQzs7R0FFRztBQUNIO0lBSUUsWUFBWSxVQUE2QjtRQUR6QyxxQkFBZ0IsR0FBRyxJQUFJLGVBQVMsRUFBa0IsQ0FBQztRQUVqRCxJQUFJLENBQUMsSUFBSSxHQUFHLFVBQVUsQ0FBQyxJQUFJLENBQUM7UUFDNUIsSUFBSSxDQUFDLFlBQVksR0FBRyxVQUFVLENBQUMsWUFBWSxDQUFDO0lBQzlDLENBQUM7SUFDRCxpQkFBaUIsQ0FBQyxpQkFBaUM7UUFDakQsSUFBSSxDQUFDLGdCQUFnQixDQUFDLEdBQUcsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0lBQy9DLENBQUM7Q0FDRjtBQVhELGdDQVdDIn0=

dist/smartsocket.classes.socketserver.d.ts

@@ -1,29 +0,0 @@
-import { Smartsocket } from './smartsocket.classes.smartsocket';
-/**
- * class socketServer
- * handles the attachment of socketIo to whatever server is in play
- */
-export declare class SocketServer {
-    private smartsocket;
-    private httpServer;
-    private standaloneServer;
-    private expressServer;
-    constructor(smartSocketInstance: Smartsocket);
-    /**
-     * starts the server with another server
-     * also works with an express style server
-     */
-    setExternalServer(serverType: 'express' | 'http', serverArg: any): Promise<void>;
-    /**
-     * gets the server for socket.io
-     */
-    getServerForSocketIo(): any;
-    /**
-     * starts listening to incoming sockets:
-     */
-    start(): Promise<void>;
-    /**
-     * closes the server
-     */
-    stop(): Promise<void>;
-}

dist/smartsocket.classes.socketserver.js

@@ -1,86 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const plugins = require("./smartsocket.plugins");
-// used in case no other server is supplied
-const http = require("http");
-/**
- * class socketServer
- * handles the attachment of socketIo to whatever server is in play
- */
-class SocketServer {
-    constructor(smartSocketInstance) {
-        // wether httpServer is standalone
-        this.standaloneServer = false;
-        this.smartsocket = smartSocketInstance;
-    }
-    /**
-     * starts the server with another server
-     * also works with an express style server
-     */
-    setExternalServer(serverType, serverArg) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (serverType === 'http') {
-                this.httpServer = serverArg;
-            }
-            else if (serverType === 'express') {
-                this.expressServer = serverArg;
-            }
-        });
-    }
-    /**
-     * gets the server for socket.io
-     */
-    getServerForSocketIo() {
-        if (this.httpServer) {
-            return this.httpServer;
-        }
-        else if (this.expressServer) {
-            return this.expressServer;
-        }
-        else if (!this.httpServer && !this.expressServer) {
-            this.httpServer = new http.Server();
-            this.standaloneServer = true;
-            return this.httpServer;
-        }
-        else {
-            throw new Error('no server specified!');
-        }
-    }
-    /**
-     * starts listening to incoming sockets:
-     */
-    start() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const done = plugins.smartq.defer();
-            // handle http servers
-            if (this.httpServer && this.standaloneServer) {
-                this.httpServer.listen(this.smartsocket.options.port, () => {
-                    console.log(`Server started in standalone mode on ${this.smartsocket.options.port}`);
-                    done.resolve();
-                });
-            }
-            else {
-                done.resolve();
-            }
-            // nothing else to do if express server is set
-            yield done.promise;
-            return;
-        });
-    }
-    /**
-     * closes the server
-     */
-    stop() {
-        return __awaiter(this, void 0, void 0, function* () { });
-    }
-}
-exports.SocketServer = SocketServer;
-//# sourceMappingURL=data:application/json;base64,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

dist/smartsocket.helpers.d.ts

@@ -1,15 +0,0 @@
-import { Smartsocket } from './smartsocket.classes.smartsocket';
-import { SocketFunction } from './smartsocket.classes.socketfunction';
-import { ISocketConnectionAuthenticationObject } from './smartsocket.classes.socketconnection';
-import { SocketRequest, TSocketRequestSide } from './smartsocket.classes.socketrequest';
-import { SocketRole } from './smartsocket.classes.socketrole';
-export declare let checkPasswordForRole: (dataArg: ISocketConnectionAuthenticationObject, referenceSmartsocket: Smartsocket) => boolean;
-export declare let getSocketFunctionByName: (functionNameArg: string) => SocketFunction;
-/**
- * get corresponding Socketrequest instance by shortId
- */
-export declare let getSocketRequestById: (shortIdArg: string, requestSide?: TSocketRequestSide) => SocketRequest;
-/**
- * get corresponding SocketRole instance by name
- */
-export declare let getSocketRoleByName: (socketRoleNameArg: string, referenceSmartsocket: Smartsocket) => SocketRole;

dist/smartsocket.helpers.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const plugins = require("./smartsocket.plugins");
-const smartsocket_classes_socketfunction_1 = require("./smartsocket.classes.socketfunction");
-const smartsocket_classes_socketrequest_1 = require("./smartsocket.classes.socketrequest");
-// SocketConnection helpers
-exports.checkPasswordForRole = (dataArg, referenceSmartsocket) => {
-    let targetPasswordHash = exports.getSocketRoleByName(dataArg.role, referenceSmartsocket).passwordHash;
-    let computedCompareHash = plugins.nodehash.sha256FromStringSync(dataArg.password);
-    return targetPasswordHash === computedCompareHash;
-};
-// SocketFunction helpers
-exports.getSocketFunctionByName = (functionNameArg) => {
-    return smartsocket_classes_socketfunction_1.allSocketFunctions.find(socketFunctionArg => {
-        return socketFunctionArg.name === functionNameArg;
-    });
-};
-// SocketRequest helpers
-/**
- * get corresponding Socketrequest instance by shortId
- */
-exports.getSocketRequestById = (shortIdArg, requestSide) => {
-    return smartsocket_classes_socketrequest_1.allSocketRequests.find(socketRequestArg => {
-        return socketRequestArg.shortid === shortIdArg;
-    });
-};
-// SocketRole helpers
-/**
- * get corresponding SocketRole instance by name
- */
-exports.getSocketRoleByName = (socketRoleNameArg, referenceSmartsocket) => {
-    return referenceSmartsocket.socketRoles.find(socketRoleArg => {
-        return socketRoleArg.name === socketRoleNameArg;
-    });
-};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQuaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LmhlbHBlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxpREFBaUQ7QUFJakQsNkZBQTBGO0FBSzFGLDJGQUk2QztBQUc3QywyQkFBMkI7QUFDaEIsUUFBQSxvQkFBb0IsR0FBRyxDQUNoQyxPQUE4QyxFQUM5QyxvQkFBaUMsRUFDeEIsRUFBRTtJQUNYLElBQUksa0JBQWtCLEdBQUcsMkJBQW1CLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxvQkFBb0IsQ0FBQyxDQUFDLFlBQVksQ0FBQztJQUM5RixJQUFJLG1CQUFtQixHQUFHLE9BQU8sQ0FBQyxRQUFRLENBQUMsb0JBQW9CLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQ2xGLE1BQU0sQ0FBQyxrQkFBa0IsS0FBSyxtQkFBbUIsQ0FBQztBQUNwRCxDQUFDLENBQUM7QUFFRix5QkFBeUI7QUFDZCxRQUFBLHVCQUF1QixHQUFHLENBQUMsZUFBdUIsRUFBa0IsRUFBRTtJQUMvRSxNQUFNLENBQUMsdURBQWtCLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLEVBQUU7UUFDakQsTUFBTSxDQUFDLGlCQUFpQixDQUFDLElBQUksS0FBSyxlQUFlLENBQUM7SUFDcEQsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDLENBQUM7QUFFRix3QkFBd0I7QUFFeEI7O0dBRUc7QUFDUSxRQUFBLG9CQUFvQixHQUFHLENBQ2hDLFVBQWtCLEVBQ2xCLFdBQWdDLEVBQ2pCLEVBQUU7SUFDakIsTUFBTSxDQUFDLHFEQUFpQixDQUFDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxFQUFFO1FBQy9DLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxPQUFPLEtBQUssVUFBVSxDQUFDO0lBQ2pELENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyxDQUFDO0FBRUYscUJBQXFCO0FBRXJCOztHQUVHO0FBQ1EsUUFBQSxtQkFBbUIsR0FBRyxDQUMvQixpQkFBeUIsRUFDekIsb0JBQWlDLEVBQ3JCLEVBQUU7SUFDZCxNQUFNLENBQUMsb0JBQW9CLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsRUFBRTtRQUMzRCxNQUFNLENBQUMsYUFBYSxDQUFDLElBQUksS0FBSyxpQkFBaUIsQ0FBQztJQUNsRCxDQUFDLENBQUMsQ0FBQztBQUNMLENBQUMsQ0FBQyJ9

dist/smartsocket.plugins.d.ts

@@ -1,8 +0,0 @@
-export import beautylog = require('beautylog');
-export import lik = require('lik');
-export import nodehash = require('nodehash');
-export import smartdelay = require('smartdelay');
-export import smartq = require('smartq');
-export import shortid = require('shortid');
-export import socketIo = require('socket.io');
-export import socketIoClient = require('socket.io-client');

dist/smartsocket.plugins.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.beautylog = require("beautylog");
-exports.lik = require("lik");
-exports.nodehash = require("nodehash");
-exports.smartdelay = require("smartdelay");
-exports.smartq = require("smartq");
-exports.shortid = require("shortid");
-exports.socketIo = require("socket.io");
-exports.socketIoClient = require("socket.io-client");
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzb2NrZXQucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c29ja2V0LnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSx5Q0FBK0M7QUFDL0MsNkJBQW1DO0FBQ25DLHVDQUE2QztBQUM3QywyQ0FBaUQ7QUFDakQsbUNBQXlDO0FBQ3pDLHFDQUEyQztBQUMzQyx3Q0FBOEM7QUFDOUMscURBQTJEIn0=

npmextra.json

@@ -1,6 +1,33 @@
 {
-  "gitzone": {},
+  "gitzone": {
+    "projectType": "npm",
+    "module": {
+      "githost": "code.foss.global",
+      "gitscope": "push.rocks",
+      "gitrepo": "smartsocket",
+      "description": "Provides easy and secure websocket communication mechanisms, including server and client implementation, function call routing, connection management, and tagging.",
+      "npmPackagename": "@push.rocks/smartsocket",
+      "license": "MIT",
+      "projectDomain": "push.rocks",
+      "keywords": [
+        "websocket",
+        "communication",
+        "server",
+        "client",
+        "socket.io",
+        "authentication",
+        "reconnection",
+        "tagging",
+        "function routing",
+        "secure"
+      ]
+    }
+  },
   "npmci": {
-    "npmGlobalTools": []
+    "npmGlobalTools": [],
+    "npmAccessLevel": "public"
+  },
+  "tsdoc": {
+    "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
   }
 }

package.json

@@ -1,42 +1,75 @@
 {
-  "name": "smartsocket",
+  "name": "@push.rocks/smartsocket",
-  "version": "1.1.21",
+  "version": "3.0.0",
-  "description": "easy and secure websocket communication, TypeScript ready",
+  "description": "Provides easy and secure websocket communication mechanisms, including server and client implementation, function call routing, connection management, and tagging.",
-  "main": "dist/index.js",
+  "main": "dist_ts/index.js",
-  "typings": "dist/index.d.ts",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
   "scripts": {
-    "test": "tstest test/",
+    "test": "(tstest test/ --verbose)",
-    "build": "echo \"Not needed for now\""
+    "build": "(tsbuild --web --allowimplicitany && tsbundle --from ./ts/index.ts --to dist_bundle/bundle.js)",
+    "buildDocs": "tsdoc"
   },
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@gitlab.com/pushrocks/smartsocket.git"
+    "url": "https://code.foss.global/push.rocks/smartsocket.git"
   },
-  "author": "Lossless GmbH",
+  "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "bugs": {
-    "url": "https://gitlab.com/pushrocks/smartsocket/issues"
+    "url": "https://community.foss.global/"
   },
-  "homepage": "https://gitlab.com/pushrocks/smartsocket#README",
+  "homepage": "https://code.foss.global/push.rocks/smartsocket",
   "dependencies": {
-    "@pushrocks/lik": "^3.0.4",
+    "@api.global/typedrequest-interfaces": "^3.0.19",
-    "@pushrocks/smartdelay": "^2.0.2",
+    "@push.rocks/isohash": "^2.0.1",
-    "@pushrocks/smarthash": "^2.0.4",
+    "@push.rocks/isounique": "^1.0.5",
-    "@pushrocks/smartlog": "^2.0.16",
+    "@push.rocks/lik": "^6.2.2",
-    "@pushrocks/smartpromise": "^2.0.5",
+    "@push.rocks/smartdelay": "^3.0.5",
-    "@types/shortid": "0.0.29",
+    "@push.rocks/smartenv": "^6.0.0",
-    "@types/socket.io": "^2.1.2",
+    "@push.rocks/smartjson": "^5.2.0",
-    "@types/socket.io-client": "^1.4.32",
+    "@push.rocks/smartlog": "^3.1.10",
-    "shortid": "^2.2.14",
+    "@push.rocks/smartpromise": "^4.2.3",
-    "socket.io": "^2.2.0",
+    "@push.rocks/smartrx": "^3.0.10",
-    "socket.io-client": "^2.2.0"
+    "@push.rocks/smarttime": "^4.1.1",
+    "ws": "^8.18.3"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.8",
+    "@git.zone/tsbuild": "^3.1.2",
-    "@gitzone/tsrun": "^1.1.17",
+    "@git.zone/tsbundle": "^2.6.3",
-    "@gitzone/tstest": "^1.0.18",
+    "@git.zone/tsrun": "^2.0.0",
-    "@pushrocks/tapbundle": "^3.0.7",
+    "@git.zone/tstest": "^3.1.3",
-    "@types/node": "^10.12.19"
+    "@push.rocks/smartserve": "^1.1.0",
+    "@types/node": "^24.10.1",
+    "@types/ws": "^8.18.1"
   },
-  "private": true
+  "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"
+  ],
+  "keywords": [
+    "websocket",
+    "communication",
+    "server",
+    "client",
+    "native websocket",
+    "authentication",
+    "reconnection",
+    "tagging",
+    "function routing",
+    "secure",
+    "rpc"
+  ]
 }

readme.hints.md

@@ -0,0 +1 @@
+ 

readme.md

@@ -0,0 +1,291 @@
+# @push.rocks/smartsocket
+
+Easy and secure WebSocket communication with native WebSocket support 🔌
+
+## Features
+
+- 🚀 **Native WebSocket** - Uses native WebSocket API (browser) and `ws` library (Node.js)
+- 🔄 **Auto Reconnection** - Exponential backoff with configurable retry limits
+- 📡 **RPC-style Function Calls** - Define and call functions across server/client
+- 🏷️ **Connection Tagging** - Tag connections for easy identification and routing
+- 🔗 **Smartserve Integration** - Works seamlessly with `@push.rocks/smartserve`
+- 🔒 **Secure Communication** - WSS support for encrypted connections
+
+## Issue Reporting and Security
+
+For reporting bugs, issues, or security vulnerabilities, please visit [community.foss.global/](https://community.foss.global/). This is the central community hub for all issue reporting. Developers who sign and comply with our contribution agreement and go through identification can also get a [code.foss.global/](https://code.foss.global/) account to submit Pull Requests directly.
+
+## Install
+
+```shell
+npm install @push.rocks/smartsocket --save
+```
+
+or with pnpm:
+
+```shell
+pnpm add @push.rocks/smartsocket
+```
+
+## Usage
+
+### Quick Start - Server
+
+```typescript
+import { Smartsocket, SocketFunction } from '@push.rocks/smartsocket';
+
+// Create server
+const server = new Smartsocket({
+  alias: 'myServer',
+  port: 3000
+});
+
+// Define a function that clients can call
+const greetFunction = new SocketFunction({
+  funcName: 'greet',
+  funcDef: async (data, socketConnection) => {
+    console.log(`Received greeting from ${data.name}`);
+    return { message: `Hello, ${data.name}!` };
+  }
+});
+
+server.addSocketFunction(greetFunction);
+
+// Start the server
+await server.start();
+console.log('WebSocket server running on port 3000');
+```
+
+### Quick Start - Client
+
+```typescript
+import { SmartsocketClient } from '@push.rocks/smartsocket';
+
+// Create client
+const client = new SmartsocketClient({
+  url: 'http://localhost',
+  port: 3000,
+  alias: 'myClient',
+  autoReconnect: true
+});
+
+// Connect to server
+await client.connect();
+
+// Call server function
+const response = await client.serverCall('greet', { name: 'Alice' });
+console.log(response.message); // "Hello, Alice!"
+```
+
+### Connection Options
+
+The `SmartsocketClient` supports several configuration options:
+
+```typescript
+const client = new SmartsocketClient({
+  url: 'http://localhost',           // Server URL (http/https)
+  port: 3000,                         // Server port
+  alias: 'myClient',                  // Client identifier
+  autoReconnect: true,                // Auto-reconnect on disconnect
+  maxRetries: 100,                    // Max reconnection attempts (default: 100)
+  initialBackoffDelay: 1000,          // Initial backoff in ms (default: 1000)
+  maxBackoffDelay: 60000              // Max backoff in ms (default: 60000)
+});
+```
+
+### Two-Way Function Calls
+
+Both server and client can define and call functions on each other:
+
+```typescript
+// Server calling client
+const clientFunction = new SocketFunction({
+  funcName: 'clientTask',
+  funcDef: async (data) => {
+    return { result: 'Task completed' };
+  }
+});
+
+// On client
+client.addSocketFunction(clientFunction);
+
+// On server - call the client
+const socketConnection = server.socketConnections.findSync(conn => conn.alias === 'myClient');
+const result = await server.clientCall('clientTask', { task: 'doSomething' }, socketConnection);
+```
+
+### Connection Tagging
+
+Tag connections to identify and group them:
+
+```typescript
+// On client
+await client.addTag({
+  id: 'role',
+  payload: 'admin'
+});
+
+// On server - find tagged connections
+const adminConnections = server.socketConnections.getArray().filter(async conn => {
+  const tag = await conn.getTagById('role');
+  return tag?.payload === 'admin';
+});
+
+// Server can also tag connections
+await socketConnection.addTag({
+  id: 'verified',
+  payload: true
+});
+```
+
+### Integration with Smartserve
+
+Use smartsocket with `@push.rocks/smartserve` for advanced HTTP/WebSocket handling:
+
+```typescript
+import { Smartserve } from '@push.rocks/smartserve';
+import { Smartsocket } from '@push.rocks/smartsocket';
+
+const smartserve = new Smartserve({ port: 3000 });
+const smartsocket = new Smartsocket({ alias: 'myServer' });
+
+// Set smartserve as external server
+await smartsocket.setExternalServer('smartserve', smartserve);
+
+// Get WebSocket hooks for smartserve
+const wsHooks = smartsocket.socketServer.getSmartserveWebSocketHooks();
+
+// Configure smartserve with the hooks
+// (see smartserve documentation for integration details)
+```
+
+### Handling Disconnections
+
+The client automatically handles reconnection with exponential backoff:
+
+```typescript
+const client = new SmartsocketClient({
+  url: 'http://localhost',
+  port: 3000,
+  alias: 'myClient',
+  autoReconnect: true,
+  maxRetries: 10,
+  initialBackoffDelay: 500,
+  maxBackoffDelay: 5000
+});
+
+// Listen for connection status changes
+client.eventSubject.subscribe(status => {
+  console.log('Connection status:', status);
+  // Status can be: 'new', 'connecting', 'connected', 'disconnecting', 'timedOut'
+});
+
+await client.connect();
+
+// Manually disconnect without auto-reconnect
+await client.disconnect();
+
+// Stop the client completely (disables auto-reconnect)
+await client.stop();
+```
+
+### Secure Connections (WSS)
+
+For secure WebSocket connections, use HTTPS URLs:
+
+```typescript
+const client = new SmartsocketClient({
+  url: 'https://secure.example.com',  // HTTPS triggers WSS
+  port: 443,
+  alias: 'secureClient'
+});
+```
+
+### TypedRequest Integration
+
+For strongly-typed RPC calls, define interfaces:
+
+```typescript
+interface IGreetRequest {
+  method: 'greet';
+  request: { name: string };
+  response: { message: string };
+}
+
+// Type-safe server call
+const response = await client.serverCall<IGreetRequest>('greet', { name: 'Bob' });
+// response is typed as { message: string }
+```
+
+## API Reference
+
+### Smartsocket (Server)
+
+| Method | Description |
+|--------|-------------|
+| `start()` | Start the WebSocket server |
+| `stop()` | Stop the server and close all connections |
+| `addSocketFunction(fn)` | Register a function that clients can call |
+| `clientCall(funcName, data, connection)` | Call a function on a specific client |
+| `setExternalServer(type, server)` | Use an external server (smartserve) |
+
+### SmartsocketClient
+
+| Method | Description |
+|--------|-------------|
+| `connect()` | Connect to the server |
+| `disconnect()` | Disconnect from the server |
+| `stop()` | Disconnect and disable auto-reconnect |
+| `serverCall(funcName, data)` | Call a function on the server |
+| `addSocketFunction(fn)` | Register a function the server can call |
+| `addTag(tag)` | Add a tag to the connection |
+| `getTagById(id)` | Get a tag by its ID |
+| `removeTagById(id)` | Remove a tag by its ID |
+
+### SocketFunction
+
+```typescript
+const fn = new SocketFunction({
+  funcName: 'myFunction',
+  funcDef: async (data, socketConnection) => {
+    // data: the request payload
+    // socketConnection: the calling connection
+    return { result: 'response' };
+  }
+});
+```
+
+## Architecture
+
+```
+┌─────────────────┐         WebSocket          ┌─────────────────┐
+│  SmartsocketClient  │◄────────────────────────►│    Smartsocket     │
+│    (Browser/Node)    │     Native WebSocket    │      (Server)       │
+└─────────────────┘                            └─────────────────┘
+        │                                                │
+        │ SocketFunction                    SocketFunction │
+        │ (serverCall)                        (clientCall) │
+        │                                                │
+        └──────────────── RPC-style Calls ──────────────┘
+```
+
+## License and Legal Information
+
+This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the [LICENSE](./LICENSE) file.
+
+**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
+
+### Trademarks
+
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH or third parties, and are not included within the scope of the MIT license granted herein.
+
+Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines or the guidelines of the respective third-party owners, and any usage must be approved in writing. Third-party trademarks used herein are the property of their respective owners and used only in a descriptive manner, e.g. for an implementation of an API or similar.
+
+### Company Information
+
+Task Venture Capital GmbH
+Registered at District Court Bremen HRB 35230 HB, Germany
+
+For any legal inquiries or further information, please contact us via email at hello@task.vc.
+
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

test/test.reconnect.ts

@@ -0,0 +1,155 @@
+import { expect, tap } from '@git.zone/tstest/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,
+    maxRetries: 20,
+    initialBackoffDelay: 500,
+    maxBackoffDelay: 3000,
+  });
+  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();
+  // Wait for client to reconnect with shorter backoff settings
+  await toolsArg.delayFor(5000);
+});
+
+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));
+});
+
+export default tap.start();

test/test.smartserve.ts

@@ -0,0 +1,91 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as smartsocket from '../ts/index.js';
+import { SmartServe } from '@push.rocks/smartserve';
+
+let smartserveInstance: SmartServe;
+let testSmartsocket: smartsocket.Smartsocket;
+let testSmartsocketClient: smartsocket.SmartsocketClient;
+let testSocketFunction: smartsocket.SocketFunction<any>;
+
+const testConfig = {
+  port: 3000,
+};
+
+// Setup smartsocket with smartserve integration
+tap.test('should create smartsocket and smartserve with websocket hooks', async () => {
+  // Create smartsocket (no port - hooks mode for smartserve integration)
+  testSmartsocket = new smartsocket.Smartsocket({ alias: 'testserver-smartserve' });
+  expect(testSmartsocket).toBeInstanceOf(smartsocket.Smartsocket);
+
+  // Get websocket hooks from smartsocket and pass to smartserve
+  const wsHooks = testSmartsocket.getSmartserveWebSocketHooks();
+  smartserveInstance = new SmartServe({
+    port: testConfig.port,
+    websocket: wsHooks,
+  });
+  // That's it! No setExternalServer needed - hooks connect everything
+});
+
+tap.test('should register a socket function', async () => {
+  testSocketFunction = new smartsocket.SocketFunction({
+    funcDef: async (dataArg, socketConnectionArg) => {
+      return dataArg;
+    },
+    funcName: 'testFunction1',
+  });
+  testSmartsocket.addSocketFunction(testSocketFunction);
+});
+
+tap.test('should start smartserve', async () => {
+  await smartserveInstance.start();
+  // No need to call testSmartsocket.start() - hooks mode doesn't need it
+});
+
+tap.test('should connect client through smartserve', async () => {
+  testSmartsocketClient = new smartsocket.SmartsocketClient({
+    port: testConfig.port,
+    url: 'http://localhost',
+    alias: 'testClient1',
+  });
+  testSmartsocketClient.addSocketFunction(testSocketFunction);
+  await testSmartsocketClient.connect();
+});
+
+tap.test('should be able to make a functionCall from client to server', async () => {
+  const response: any = await testSmartsocketClient.serverCall('testFunction1', {
+    value1: 'hello from smartserve test',
+  });
+  expect(response.value1).toEqual('hello from smartserve test');
+});
+
+tap.test('should be able to make multiple function calls', async () => {
+  for (let i = 0; i < 10; i++) {
+    const randomString = `message-${i}-${Math.random()}`;
+    const response: any = await testSmartsocketClient.serverCall('testFunction1', {
+      value1: randomString,
+    });
+    expect(response.value1).toEqual(randomString);
+  }
+});
+
+tap.test('client should disconnect and reconnect through smartserve', async (tools) => {
+  await testSmartsocketClient.disconnect();
+  await tools.delayFor(100);
+  await testSmartsocketClient.connect();
+
+  // Verify connection still works after reconnect
+  const response: any = await testSmartsocketClient.serverCall('testFunction1', {
+    value1: 'after reconnect',
+  });
+  expect(response.value1).toEqual('after reconnect');
+});
+
+// Cleanup
+tap.test('should close the server', async (tools) => {
+  await testSmartsocketClient.stop();
+  await testSmartsocket.stop();
+  await smartserveInstance.stop();
+  tools.delayFor(1000).then(() => process.exit(0));
+});
+
+export default tap.start();

test/test.tagging.ts

@@ -0,0 +1,148 @@
+import { expect, tap } from '@git.zone/tstest/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 (tools) => {
+  await testSmartsocketClient.stop();
+  await testSmartsocket.stop();
+  tools.delayFor(1000).then(() => process.exit(0));
+});
+
+export default tap.start();

test/test.ts

@@ -1,124 +0,0 @@
-// tslint:disable-next-line:no-implicit-dependencies
-import { expect, tap } from '@pushrocks/tapbundle';
-
-import * as nodehash from '@pushrocks/smarthash';
-import * as smartq from '@pushrocks/smartpromise';
-
-import socketIoClient = require('socket.io-client');
-import smartsocket = require('../ts/index');
-
-let testSmartsocket: smartsocket.Smartsocket;
-let testSmartsocketClient: smartsocket.SmartsocketClient;
-let testSocketRole1: smartsocket.SocketRole;
-let testSocketFunction1: smartsocket.SocketFunction;
-
-const testConfig = {
-  port: 3000
-};
-
-// class smartsocket
-tap.test('should create a new smartsocket', async () => {
-  testSmartsocket = new smartsocket.Smartsocket({ port: testConfig.port });
-  expect(testSmartsocket).be.instanceOf(smartsocket.Smartsocket);
-});
-
-tap.test('should start listening when .started is called', async () => {
-  await testSmartsocket.start();
-});
-
-// class socketrole
-tap.test('should add a socketrole', async () => {
-  testSocketRole1 = new smartsocket.SocketRole({
-    name: 'testRole1',
-    passwordHash: nodehash.sha256FromStringSync('testPassword')
-  });
-  testSmartsocket.addSocketRoles([testSocketRole1]);
-});
-
-// class SocketFunction
-tap.test('should register a new Function', async () => {
-  testSocketFunction1 = new smartsocket.SocketFunction({
-    allowedRoles: [testSocketRole1],
-    funcDef: async dataArg => {
-      return dataArg;
-    },
-    funcName: 'testFunction1'
-  });
-});
-
-// class SmartsocketClient
-tap.test('should react to a new websocket connection from client', async () => {
-  const done = smartq.defer();
-  testSmartsocketClient = new smartsocket.SmartsocketClient({
-    port: testConfig.port,
-    url: 'http://localhost',
-    password: 'testPassword',
-    alias: 'testClient1',
-    role: 'testRole1'
-  });
-  testSmartsocketClient.connect().then(() => {
-    done.resolve();
-  });
-  await done.promise;
-});
-tap.test('client should disconnect and reconnect', async () => {
-  let done = smartq.defer();
-  testSmartsocketClient
-    .disconnect()
-    .then(() => {
-      let done = smartq.defer();
-      setTimeout(() => {
-        testSmartsocketClient.connect().then(done.resolve);
-      }, 0);
-      return done.promise;
-    })
-    .then(() => {
-      done.resolve();
-    });
-  await done.promise;
-});
-
-tap.test('2 clients should connect in parallel', async () => {
-  // TODO: implement parallel test
-});
-
-tap.test('should be able to make a functionCall from client to server', async () => {
-  let done = smartq.defer();
-  testSmartsocketClient
-    .serverCall('testFunction1', {
-      value1: 'hello'
-    })
-    .then(dataArg => {
-      console.log(dataArg);
-      done.resolve();
-    });
-  await done.promise;
-});
-
-tap.test('should be able to make a functionCall from server to client', async () => {
-  let done = smartq.defer();
-  let targetSocket = (() => {
-    return smartsocket.allSocketConnections.find(socketConnectionArg => {
-      return socketConnectionArg.alias === 'testClient1';
-    });
-  })();
-  testSmartsocket
-    .clientCall(
-      'testFunction1',
-      {
-        value1: 'helloFromServer'
-      },
-      targetSocket
-    )
-    .then(dataArg => {
-      console.log(dataArg);
-      done.resolve();
-    });
-});
-
-// terminate
-tap.test('should close the server', async () => {
-  await testSmartsocket.stop();
-});
-
-tap.start();

ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/smartsocket',
+  version: '3.0.0',
+  description: 'Provides easy and secure websocket communication mechanisms, including server and client implementation, function call routing, connection management, and tagging.'
+}

ts/index.ts

@@ -1,10 +1,10 @@
-import * as plugins from './smartsocket.plugins';
-
 // export main classes
-export * from './smartsocket.classes.smartsocket';
+export * from './smartsocket.classes.smartsocket.js';
-export * from './smartsocket.classes.smartsocketclient';
+export * from './smartsocket.classes.smartsocketclient.js';
 
 // export further classes and objects
-export * from './smartsocket.classes.socketfunction';
+export * from './smartsocket.classes.socketfunction.js';
-export * from './smartsocket.classes.socketrole';
+export * from './smartsocket.classes.socketconnection.js';
-export * from './smartsocket.classes.socketconnection';
+
+// export types so they can be referred to
+export * from './interfaces/index.js';

ts/interfaces/connection.ts

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

ts/interfaces/index.ts

@@ -0,0 +1,3 @@
+export * from './connection.js';
+export * from './tag.js';
+export * from './message.js';

ts/interfaces/message.ts

@@ -0,0 +1,67 @@
+/**
+ * Message types for the smartsocket protocol
+ */
+export type TMessageType =
+  | 'authRequest'      // Server requests authentication from client
+  | 'auth'             // Client provides authentication data
+  | 'authResponse'     // Server responds to authentication
+  | 'serverReady'      // Server signals it's fully ready
+  | 'function'         // Function call request
+  | 'functionResponse' // Function call response
+  | 'tagUpdate';       // Tag store synchronization
+
+/**
+ * Base message interface for all smartsocket messages
+ */
+export interface ISocketMessage<T = any> {
+  type: TMessageType;
+  id?: string;         // For request/response correlation
+  payload: T;
+}
+
+/**
+ * Authentication request payload (server -> client)
+ */
+export interface IAuthRequestPayload {
+  serverAlias: string;
+}
+
+/**
+ * Authentication data payload (client -> server)
+ */
+export interface IAuthPayload {
+  alias: string;
+}
+
+/**
+ * Authentication response payload (server -> client)
+ */
+export interface IAuthResponsePayload {
+  success: boolean;
+  error?: string;
+}
+
+/**
+ * Function call payload
+ */
+export interface IFunctionCallPayload {
+  funcName: string;
+  funcData: any;
+}
+
+/**
+ * Tag update payload
+ */
+export interface ITagUpdatePayload {
+  tags: { [key: string]: any };
+}
+
+/**
+ * Helper type for creating typed messages
+ */
+export type TAuthRequestMessage = ISocketMessage<IAuthRequestPayload>;
+export type TAuthMessage = ISocketMessage<IAuthPayload>;
+export type TAuthResponseMessage = ISocketMessage<IAuthResponsePayload>;
+export type TFunctionMessage = ISocketMessage<IFunctionCallPayload>;
+export type TFunctionResponseMessage = ISocketMessage<IFunctionCallPayload>;
+export type TTagUpdateMessage = ISocketMessage<ITagUpdatePayload>;

ts/interfaces/tag.ts

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

ts/smartsocket.classes.smartsocket.ts

@@ -1,45 +1,97 @@
-import * as plugins from './smartsocket.plugins';
+import * as plugins from './smartsocket.plugins.js';
-import * as helpers from './smartsocket.helpers';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';
+import * as interfaces from './interfaces/index.js';
 
 // classes
-import { Objectmap } from '@pushrocks/lik';
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
-import { SocketConnection } from './smartsocket.classes.socketconnection';
+import {
-import { ISocketFunctionCall, SocketFunction } from './smartsocket.classes.socketfunction';
+  type ISocketFunctionCallDataRequest,
-import { SocketRequest } from './smartsocket.classes.socketrequest';
+  SocketFunction,
-import { SocketRole } from './smartsocket.classes.socketrole';
+  type ISocketFunctionCallDataResponse,
-import { SocketServer } from './smartsocket.classes.socketserver';
+} from './smartsocket.classes.socketfunction.js';
+import { SocketRequest } from './smartsocket.classes.socketrequest.js';
+import { SocketServer } from './smartsocket.classes.socketserver.js';
 
-// socket.io
+import { logger } from './smartsocket.logging.js';
-import * as SocketIO from 'socket.io';
 
 export interface ISmartsocketConstructorOptions {
-  port: number;
+  alias: string;
+  port?: number;
 }
 
 export class Smartsocket {
+  /**
+   * a unique id to detect server restarts
+   */
+  public alias: string;
+  public smartenv = new plugins.smartenv.Smartenv();
   public options: ISmartsocketConstructorOptions;
-  public io: SocketIO.Server;
+  public socketConnections = new plugins.lik.ObjectMap<SocketConnection>();
-  public openSockets = new Objectmap<SocketConnection>();
+  public socketFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
-  public socketRoles = new Objectmap<SocketRole>();
+  public socketRequests = new plugins.lik.ObjectMap<SocketRequest<any>>();
+
+  public eventSubject = new plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>();
 
   private socketServer = new SocketServer(this);
 
   constructor(optionsArg: ISmartsocketConstructorOptions) {
     this.options = optionsArg;
+    this.alias = plugins.isounique.uni(this.options.alias);
   }
 
-  // tslint:disable-next-line:member-ordering
+  /**
-  public setExternalServer = this.socketServer.setExternalServer;
+   * Returns WebSocket hooks for integration with smartserve
+   * Pass these hooks to SmartServe's websocket config
+   */
+  public getSmartserveWebSocketHooks(): pluginsTyped.ISmartserveWebSocketHooks {
+    return this.socketServer.getSmartserveWebSocketHooks();
+  }
 
   /**
    * starts smartsocket
    */
   public async start() {
-    this.io = plugins.socketIo(this.socketServer.getServerForSocketIo());
     await this.socketServer.start();
-    this.io.on('connection', socketArg => {
+  }
-      this._handleSocketConnection(socketArg);
+
+  /**
+   * Handle a new WebSocket connection
+   * Called by SocketServer when a new connection is established
+   */
+  public async handleNewConnection(socket: WebSocket | pluginsTyped.ws.WebSocket) {
+    const socketConnection: SocketConnection = new SocketConnection({
+      alias: undefined,
+      authenticated: false,
+      side: 'server',
+      smartsocketHost: this,
+      socket: socket,
     });
+
+    logger.log('info', 'Socket connected. Trying to authenticate...');
+    this.socketConnections.add(socketConnection);
+
+    // Handle disconnection
+    const handleClose = () => {
+      this.socketConnections.remove(socketConnection);
+      socketConnection.eventSubject.next('disconnected');
+    };
+
+    socket.addEventListener('close', handleClose);
+    socket.addEventListener('error', handleClose);
+
+    try {
+      await socketConnection.authenticate();
+      await socketConnection.listenToFunctionRequests();
+
+      // Signal that the server is ready
+      socketConnection.sendMessage({
+        type: 'serverReady',
+        payload: {},
+      });
+    } catch (err) {
+      logger.log('warn', `Authentication failed: ${err}`);
+      this.socketConnections.remove(socketConnection);
+    }
   }
 
   /**
@@ -47,18 +99,19 @@ export class Smartsocket {
    */
   public async stop() {
     await plugins.smartdelay.delayFor(1000);
-    this.openSockets.forEach((socketObjectArg: SocketConnection) => {
+    this.socketConnections.forEach((socketObjectArg: SocketConnection) => {
-      plugins.smartlog.defaultLogger.log(
+      if (socketObjectArg) {
+        logger.log(
           'info',
-        `disconnect socket with >>alias ${socketObjectArg.alias}`
+          `disconnecting socket with >>alias ${socketObjectArg.alias} due to server stop...`
         );
-      socketObjectArg.socket.disconnect();
+        socketObjectArg.disconnect();
+      }
     });
-    this.openSockets.wipe();
+    this.socketConnections.wipe();
-    this.io.close();
 
-    // stop the corresponging server
+    // stop the corresponding server
-    this.socketServer.stop();
+    await this.socketServer.stop();
   }
 
   // communication
@@ -66,59 +119,26 @@ export class Smartsocket {
   /**
    * allows call to specific client.
    */
-  public async clientCall(
+  public async clientCall<T extends plugins.typedrequestInterfaces.ITypedRequest>(
-    functionNameArg: string,
+    functionNameArg: T['method'],
-    dataArg: any,
+    dataArg: T['request'],
     targetSocketConnectionArg: SocketConnection
-  ) {
+  ): Promise<T['response']> {
-    const done = plugins.smartpromise.defer();
+    const socketRequest = new SocketRequest<T>(this, {
-    const socketRequest = new SocketRequest({
       funcCallData: {
         funcDataArg: dataArg,
-        funcName: functionNameArg
+        funcName: functionNameArg,
       },
       originSocketConnection: targetSocketConnectionArg,
-      shortId: plugins.shortid.generate(),
+      shortId: plugins.isounique.uni(),
-      side: 'requesting'
+      side: 'requesting',
     });
-    socketRequest.dispatch().then((dataArg: ISocketFunctionCall) => {
+    const response: ISocketFunctionCallDataResponse<T> = await socketRequest.dispatch();
-      done.resolve(dataArg.funcDataArg);
+    const result = response.funcDataArg;
-    });
-    const result = await done.promise;
     return result;
   }
 
-  /**
+  public addSocketFunction(socketFunction: SocketFunction<any>) {
-   * adds socketRoles
+    this.socketFunctions.add(socketFunction);
-   */
-  public addSocketRoles(socketRolesArray: SocketRole[]): void {
-    for (const socketRole of socketRolesArray) {
-      this.socketRoles.add(socketRole);
-    }
-    return;
-  }
-
-  /**
-   * the standard handler for new socket connections
-   */
-  private _handleSocketConnection(socketArg) {
-    const socketConnection: SocketConnection = new SocketConnection({
-      alias: undefined,
-      authenticated: false,
-      role: undefined,
-      side: 'server',
-      smartsocketHost: this,
-      socket: socketArg
-    });
-    plugins.smartlog.defaultLogger.log('info', 'Socket connected. Trying to authenticate...');
-    this.openSockets.add(socketConnection);
-    socketConnection
-      .authenticate()
-      .then(() => {
-        return socketConnection.listenToFunctionRequests();
-      })
-      .catch(err => {
-        console.log(err);
-      });
   }
 }

ts/smartsocket.classes.smartsocketclient.ts

@@ -1,8 +1,14 @@
-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';
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
-import { ISocketFunctionCall, SocketFunction } from './smartsocket.classes.socketfunction';
+import {
-import { ISocketRequestDataObject, SocketRequest } from './smartsocket.classes.socketrequest';
+  type ISocketFunctionCallDataRequest,
+  SocketFunction,
+} from './smartsocket.classes.socketfunction.js';
+import { type ISocketRequestDataObject, SocketRequest } from './smartsocket.classes.socketrequest.js';
+import { logger } from './smartsocket.logging.js';
 
 /**
  * interface for class SmartsocketClient
@@ -10,81 +16,354 @@ import { ISocketRequestDataObject, SocketRequest } from './smartsocket.classes.s
 export interface ISmartsocketClientOptions {
   port: number;
   url: string;
-  alias: string; // an alias makes it easier to identify this client in a multo client environment
+  alias: string; // an alias makes it easier to identify this client in a multi client environment
-  role: string;
+  autoReconnect?: boolean;
-  password: string; // by setting a password access to functions can be limited
+  maxRetries?: number; // maximum number of reconnection attempts
+  initialBackoffDelay?: number; // initial backoff delay in ms
+  maxBackoffDelay?: number; // maximum backoff delay in ms
 }
 
 export class SmartsocketClient {
-  alias: string;
+  // a unique id
-  role: string;
+  public shortId = plugins.isounique.uni();
-  socketConnection: SocketConnection;
+
-  serverUrl: string;
+  // the shortId of the remote we connect to
-  serverPort: number;
+  public remoteShortId: string = null;
-  serverPassword: string;
+
+  public alias: string;
+  public socketConnection: SocketConnection;
+  public serverUrl: string;
+  public serverPort: number;
+  public autoReconnect: boolean;
+  public maxRetries: number;
+  public initialBackoffDelay: number;
+  public maxBackoffDelay: number;
+  public currentRetryCount = 0;
+  public currentBackoffDelay: number;
+
+  // 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.role = optionsArg.role;
     this.serverUrl = optionsArg.url;
     this.serverPort = optionsArg.port;
-    this.serverPassword = optionsArg.password;
+    this.autoReconnect = optionsArg.autoReconnect;
+    this.maxRetries = optionsArg.maxRetries ?? 100; // Default to 100 retries
+    this.initialBackoffDelay = optionsArg.initialBackoffDelay ?? 1000; // Default to 1 second
+    this.maxBackoffDelay = optionsArg.maxBackoffDelay ?? 60000; // Default to 1 minute
+    this.currentBackoffDelay = this.initialBackoffDelay;
   }
 
+  public addSocketFunction(socketFunction: SocketFunction<any>) {
+    this.socketFunctions.add(socketFunction);
+  }
+
+  private isReconnecting = false;
+
   /**
    * connect the client to the server
    */
-  connect() {
+  public async connect() {
-    let done = plugins.smartpromise.defer();
+    // Only reset retry counters on fresh connection (not during auto-reconnect)
-    plugins.smartlog.defaultLogger.log('info', 'trying to connect...');
+    if (!this.isReconnecting) {
-    let socketUrl = `${this.serverUrl}:${this.serverPort}`;
+      this.currentRetryCount = 0;
+      this.currentBackoffDelay = this.initialBackoffDelay;
+    }
+    this.isReconnecting = false;
+
+    const done = plugins.smartpromise.defer();
+    const smartenvInstance = new plugins.smartenv.Smartenv();
+
+    logger.log('info', 'trying to connect...');
+
+    // Construct WebSocket URL
+    const protocol = this.serverUrl.startsWith('https') ? 'wss' : 'ws';
+    const host = this.serverUrl.replace(/^https?:\/\//, '');
+    const socketUrl = `${protocol}://${host}:${this.serverPort}`;
+
+    // Get WebSocket implementation (native in browser, ws in Node)
+    let WebSocketClass: typeof WebSocket;
+    if (typeof WebSocket !== 'undefined') {
+      // Browser environment
+      WebSocketClass = WebSocket;
+    } else {
+      // Node.js environment
+      const wsModule = await smartenvInstance.getSafeNodeModule('ws');
+      WebSocketClass = wsModule.default || wsModule;
+    }
+
+    const socket = new WebSocketClass(socketUrl);
+    this.currentSocket = socket;
+
     this.socketConnection = new SocketConnection({
       alias: this.alias,
       authenticated: false,
-      role: undefined,
       side: 'client',
-      smartsocketHost: null,
+      smartsocketHost: this,
-      socket: plugins.socketIoClient(socketUrl, { multiplex: false })
+      socket: socket as any,
     });
-    this.socketConnection.socket.on('requestAuth', () => {
+
-      console.log('server requested authentication');
+    // Increment attempt ID to invalidate any pending timers from previous attempts
-      this.socketConnection.socket.emit('dataAuth', {
+    this.connectionAttemptId++;
-        role: this.role,
+    const currentAttemptId = this.connectionAttemptId;
-        password: this.serverPassword,
+
-        alias: this.alias
+    const timer = new plugins.smarttime.Timer(5000);
+    timer.start();
+    timer.completed.then(() => {
+      // Only fire timeout if this is still the current connection attempt
+      if (currentAttemptId === this.connectionAttemptId && this.eventStatus !== 'connected') {
+        this.updateStatus('timedOut');
+        logger.log('warn', 'connection to server timed out.');
+        this.disconnect(true);
+      }
     });
-      this.socketConnection.socket.on('authenticated', () => {
+
-        console.log('client is authenticated');
+    // Handle connection open
+    socket.addEventListener('open', () => {
+      timer.reset();
+    });
+
+    // Handle messages
+    socket.addEventListener('message', async (event: MessageEvent | { data: string }) => {
+      try {
+        const data = typeof event.data === 'string' ? event.data : event.data.toString();
+        const message: interfaces.ISocketMessage = JSON.parse(data);
+
+        switch (message.type) {
+          case 'authRequest':
+            timer.reset();
+            const authRequestPayload = message.payload as interfaces.IAuthRequestPayload;
+            logger.log('info', `server ${authRequestPayload.serverAlias} requested authentication`);
+            this.remoteShortId = authRequestPayload.serverAlias;
+
+            // Send authentication data
+            this.socketConnection.sendMessage({
+              type: 'auth',
+              payload: { alias: this.alias },
+            });
+            break;
+
+          case 'authResponse':
+            const authResponse = message.payload as interfaces.IAuthResponsePayload;
+            if (authResponse.success) {
+              logger.log('info', 'client is authenticated');
               this.socketConnection.authenticated = true;
-        this.socketConnection.listenToFunctionRequests();
+            } else {
+              logger.log('warn', `authentication failed: ${authResponse.error}`);
+              await this.disconnect();
+            }
+            break;
+
+          case 'serverReady':
+            // Set up function request listening
+            await this.socketConnection.listenToFunctionRequests();
+
+            // Handle 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();
+            break;
+
+          default:
+            // Other messages are handled by SocketConnection
+            this.socketConnection.handleMessage(message);
+            break;
+        }
+      } catch (err) {
+        // Not a valid JSON message, ignore
+      }
     });
-    });
+
+    // Handle disconnection and errors
+    const closeHandler = async () => {
+      // Only handle close if this is still the current socket and we're not already disconnecting
+      if (this.currentSocket === socket && !this.disconnectRunning) {
+        logger.log(
+          'info',
+          `SocketConnection with >alias ${this.alias} on >side client disconnected`
+        );
+        await this.disconnect(true);
+      }
+    };
+
+    const errorHandler = async () => {
+      if (this.currentSocket === socket && !this.disconnectRunning) {
+        await this.disconnect(true);
+      }
+    };
+
+    socket.addEventListener('close', closeHandler);
+    socket.addEventListener('error', errorHandler);
+
     return done.promise;
   }
 
-  disconnect() {
+  private disconnectRunning = false;
-    let done = plugins.smartpromise.defer();
+  private currentSocket: WebSocket | null = null;
-    this.socketConnection.socket.disconnect();
+  private connectionAttemptId = 0; // Increment on each connect attempt to invalidate old timers
+
+  /**
+   * disconnect from the server
+   */
+  public async disconnect(useAutoReconnectSetting = false) {
+    if (this.disconnectRunning) {
+      return;
+    }
+    this.disconnectRunning = true;
+    this.updateStatus('disconnecting');
+    this.tagStoreSubscription?.unsubscribe();
+
+    // Store reference to current socket before cleanup
+    const socketToClose = this.currentSocket;
+    this.currentSocket = null;
+
+    if (this.socketConnection) {
+      await this.socketConnection.disconnect();
       this.socketConnection = undefined;
-    plugins.smartlog.defaultLogger.log('ok', 'disconnected!');
+      logger.log('ok', 'disconnected socket!');
-    done.resolve();
+    } else if (!socketToClose) {
-    return done.promise;
+      this.disconnectRunning = false;
+      logger.log('warn', 'tried to disconnect, without a SocketConnection');
+      return;
     }
 
-  serverCall(functionNameArg: string, dataArg: any) {
+    logger.log('warn', `disconnected from server ${this.remoteShortId}`);
-    let done = plugins.smartpromise.defer();
+    this.remoteShortId = null;
-    let socketRequest = new SocketRequest({
+
+    if (this.autoReconnect && useAutoReconnectSetting && this.eventStatus !== 'connecting') {
+      this.updateStatus('connecting');
+
+      // Check if we've exceeded the maximum number of retries
+      if (this.currentRetryCount >= this.maxRetries) {
+        logger.log('warn', `Maximum reconnection attempts (${this.maxRetries}) reached. Giving up.`);
+        this.disconnectRunning = false;
+        return;
+      }
+
+      // Increment retry counter
+      this.currentRetryCount++;
+
+      // Calculate backoff with jitter (±20% randomness)
+      const jitter = this.currentBackoffDelay * 0.2 * (Math.random() * 2 - 1);
+      const delay = Math.min(this.currentBackoffDelay + jitter, this.maxBackoffDelay);
+
+      logger.log('info', `Reconnect attempt ${this.currentRetryCount}/${this.maxRetries} in ${Math.round(delay)}ms`);
+
+      // Apply exponential backoff for next time (doubling with each attempt)
+      this.currentBackoffDelay = Math.min(this.currentBackoffDelay * 2, this.maxBackoffDelay);
+
+      await plugins.smartdelay.delayFor(delay);
+      this.disconnectRunning = false;
+      this.isReconnecting = true;
+      await this.connect();
+    } else {
+      this.disconnectRunning = false;
+    }
+  }
+
+  /**
+   * stops the client completely
+   */
+  public async stop() {
+    this.autoReconnect = false;
+    this.currentRetryCount = 0;
+    this.currentBackoffDelay = this.initialBackoffDelay;
+    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 socketRequest = new SocketRequest<T>(this, {
       side: 'requesting',
       originSocketConnection: this.socketConnection,
-      shortId: plugins.shortid.generate(),
+      shortId: plugins.isounique.uni(),
       funcCallData: {
         funcName: functionNameArg,
-        funcDataArg: dataArg
+        funcDataArg: dataArg,
-      }
+      },
     });
-    socketRequest.dispatch().then((dataArg: ISocketFunctionCall) => {
+    const response = await socketRequest.dispatch();
-      done.resolve(dataArg.funcDataArg);
+    const result = response.funcDataArg;
-    });
+    return result;
-    return done.promise;
+  }
+
+  private updateStatus(statusArg: interfaces.TConnectionStatus) {
+    if (this.eventStatus !== statusArg) {
+      this.eventSubject.next(statusArg);
+    }
+    this.eventStatus = statusArg;
+
+    // Reset reconnection state when connection is successful
+    if (statusArg === 'connected') {
+      this.currentRetryCount = 0;
+      this.currentBackoffDelay = this.initialBackoffDelay;
+    }
+  }
+
+  /**
+   * Resets the reconnection state
+   */
+  public resetReconnectionState() {
+    this.currentRetryCount = 0;
+    this.currentBackoffDelay = this.initialBackoffDelay;
   }
 }

ts/smartsocket.classes.socketconnection.ts

@@ -1,20 +1,15 @@
-import * as plugins from './smartsocket.plugins';
+import * as plugins from './smartsocket.plugins.js';
-import * as helpers from './smartsocket.helpers';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';
-
+import * as interfaces from './interfaces/index.js';
-import { Objectmap } from '@pushrocks/lik';
 
 // import classes
-import { Smartsocket } from './smartsocket.classes.smartsocket';
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
-import { SocketFunction } from './smartsocket.classes.socketfunction';
+import { SocketFunction } from './smartsocket.classes.socketfunction.js';
-import {
+import { SocketRequest, type ISocketRequestDataObject } from './smartsocket.classes.socketrequest.js';
-  SocketRequest,
-  ISocketRequestDataObject,
-  allSocketRequests
-} from './smartsocket.classes.socketrequest';
-import { SocketRole } from './smartsocket.classes.socketrole';
 
 // socket.io
-import * as SocketIO from 'socket.io';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient.js';
+import { logger } from './smartsocket.logging.js';
 
 // export interfaces
 
@@ -29,85 +24,238 @@ export type TSocketConnectionSide = 'server' | 'client';
 export interface ISocketConnectionConstructorOptions {
   alias: string;
   authenticated: boolean;
-  role: SocketRole;
   side: TSocketConnectionSide;
-  smartsocketHost: Smartsocket;
+  smartsocketHost: Smartsocket | SmartsocketClient;
-  socket: SocketIO.Socket | SocketIOClient.Socket;
+  socket: WebSocket | pluginsTyped.ws.WebSocket;
 }
 
 /**
  * interface for authentication data
  */
 export interface ISocketConnectionAuthenticationObject {
-  role: 'coreflowContainer';
+  alias: string;
-  password: 'somePassword';
-  alias: 'coreflow1';
 }
 
 // export classes
-export let allSocketConnections = new Objectmap<SocketConnection>();
+export let allSocketConnections = new plugins.lik.ObjectMap<SocketConnection>();
 
 /**
  * class SocketConnection represents a websocket connection
  */
 export class SocketConnection {
-  alias: string;
+  public alias: string;
-  side: TSocketConnectionSide;
+  public side: TSocketConnectionSide;
-  authenticated: boolean = false;
+  public authenticated: boolean = false;
-  role: SocketRole;
+  public smartsocketRef: Smartsocket | SmartsocketClient;
-  smartsocketHost: Smartsocket;
+  public socket: WebSocket | pluginsTyped.ws.WebSocket;
-  socket: any; // SocketIO.Socket | SocketIOClient.Socket
+
+  public eventSubject = new plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>();
+  public eventStatus: interfaces.TConnectionStatus = 'new';
+
+  private tagStore: interfaces.TTagStore = {};
+  public tagStoreObservable = new plugins.smartrx.rxjs.Subject<interfaces.TTagStore>();
+  public remoteTagStoreObservable = new plugins.smartrx.rxjs.Subject<interfaces.TTagStore>();
+
   constructor(optionsArg: ISocketConnectionConstructorOptions) {
     this.alias = optionsArg.alias;
     this.authenticated = optionsArg.authenticated;
-    this.role = optionsArg.role;
     this.side = optionsArg.side;
-    this.smartsocketHost = optionsArg.smartsocketHost;
+    this.smartsocketRef = optionsArg.smartsocketHost;
     this.socket = optionsArg.socket;
 
     // standard behaviour that is always true
     allSocketConnections.add(this);
-    this.socket.on('disconnect', () => {
+  }
-      plugins.smartlog.defaultLogger.log(
+
-        'info',
+  /**
-        `SocketConnection with >alias ${this.alias} on >side ${this.side} disconnected`
+   * Sends a message through the socket
+   */
+  public sendMessage(message: interfaces.ISocketMessage): void {
+    if (this.socket.readyState === 1) { // WebSocket.OPEN
+      this.socket.send(JSON.stringify(message));
+    }
+  }
+
+  /**
+   * Handles incoming messages
+   */
+  public handleMessage(messageData: interfaces.ISocketMessage): void {
+    switch (messageData.type) {
+      case 'function':
+        this.handleFunctionCall(messageData);
+        break;
+      case 'functionResponse':
+        this.handleFunctionResponse(messageData);
+        break;
+      case 'tagUpdate':
+        this.handleTagUpdate(messageData);
+        break;
+      default:
+        // Authentication messages are handled by the server/client classes
+        break;
+    }
+  }
+
+  private handleFunctionCall(messageData: interfaces.ISocketMessage): void {
+    const requestData: ISocketRequestDataObject<any> = {
+      funcCallData: {
+        funcName: messageData.payload.funcName,
+        funcDataArg: messageData.payload.funcData,
+      },
+      shortId: messageData.id,
+    };
+
+    const referencedFunction: SocketFunction<any> =
+      this.smartsocketRef.socketFunctions.findSync((socketFunctionArg) => {
+        return socketFunctionArg.name === requestData.funcCallData.funcName;
+      });
+
+    if (referencedFunction) {
+      const localSocketRequest = new SocketRequest(this.smartsocketRef, {
+        side: 'responding',
+        originSocketConnection: this,
+        shortId: requestData.shortId,
+        funcCallData: requestData.funcCallData,
+      });
+      localSocketRequest.createResponse();
+    } else {
+      logger.log('warn', `function ${requestData.funcCallData.funcName} not found or out of scope`);
+    }
+  }
+
+  private handleFunctionResponse(messageData: interfaces.ISocketMessage): void {
+    const responseData: ISocketRequestDataObject<any> = {
+      funcCallData: {
+        funcName: messageData.payload.funcName,
+        funcDataArg: messageData.payload.funcData,
+      },
+      shortId: messageData.id,
+    };
+
+    const targetSocketRequest = SocketRequest.getSocketRequestById(
+      this.smartsocketRef,
+      responseData.shortId
     );
-      this.socket.disconnect();
+    if (targetSocketRequest) {
-      allSocketConnections.remove(this);
+      targetSocketRequest.handleResponse(responseData);
+    }
+  }
+
+  private handleTagUpdate(messageData: interfaces.ISocketMessage): void {
+    const tagStoreArg = messageData.payload.tags as interfaces.TTagStore;
+    if (!plugins.smartjson.deepEqualObjects(this.tagStore, tagStoreArg)) {
+      this.tagStore = tagStoreArg;
+      // Echo back to confirm
+      this.sendMessage({
+        type: 'tagUpdate',
+        payload: { tags: this.tagStore },
+      });
+      this.tagStoreObservable.next(this.tagStore);
+    }
+    this.remoteTagStoreObservable.next(tagStoreArg);
+  }
+
+  /**
+   * 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.sendMessage({
+      type: 'tagUpdate',
+      payload: { tags: 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.sendMessage({
+      type: 'tagUpdate',
+      payload: { tags: this.tagStore },
     });
   }
 
   // authenticating --------------------------
 
   /**
-   * authenticate the socket
+   * authenticate the socket (server side)
    */
-  authenticate() {
+  public authenticate(): Promise<SocketConnection> {
-    let done = plugins.smartpromise.defer();
+    const done = plugins.smartpromise.defer<SocketConnection>();
-    this.socket.on('dataAuth', (dataArg: ISocketConnectionAuthenticationObject) => {
+
-      plugins.smartlog.defaultLogger.log(
+    // Set up message handler for authentication
-        'info',
+    const messageHandler = (event: MessageEvent | { data: string }) => {
-        'received authentication data. now hashing and comparing...'
+      try {
-      );
+        const data = typeof event.data === 'string' ? event.data : event.data.toString();
-      this.socket.removeListener('dataAuth', () => {});
+        const message: interfaces.ISocketMessage = JSON.parse(data);
-      if (helpers.checkPasswordForRole(dataArg, this.smartsocketHost)) {
+
-        // TODO: authenticate password
+        if (message.type === 'auth') {
-        this.alias = dataArg.alias;
+          const authData = message.payload as interfaces.IAuthPayload;
+          logger.log('info', 'received authentication data...');
+
+          if (authData.alias) {
+            this.alias = authData.alias;
             this.authenticated = true;
-        this.role = helpers.getSocketRoleByName(dataArg.role, this.smartsocketHost);
+
-        this.socket.emit('authenticated');
+            // Send authentication response
-        plugins.smartlog.defaultLogger.log(
+            this.sendMessage({
-          'ok',
+              type: 'authResponse',
-          `socket with >>alias ${this.alias} >>role ${this.role} is authenticated!`
+              payload: { success: true },
-        );
+            });
+
+            logger.log('ok', `socket with >>alias ${this.alias} is authenticated!`);
             done.resolve(this);
           } else {
             this.authenticated = false;
-        this.socket.disconnect();
+            this.sendMessage({
-        done.reject('not authenticated');
+              type: 'authResponse',
-      }
+              payload: { success: false, error: 'No alias provided' },
             });
-    this.socket.emit('requestAuth');
+            this.disconnect();
+            done.reject('a socket tried to connect, but could not authenticate.');
+          }
+        }
+      } catch (err) {
+        // Not a valid message, ignore
+      }
+    };
+
+    this.socket.addEventListener('message', messageHandler as any);
+
+    // Request authentication
+    const requestAuthPayload: interfaces.TAuthRequestMessage = {
+      type: 'authRequest',
+      payload: {
+        serverAlias: (this.smartsocketRef as Smartsocket).alias,
+      },
+    };
+    this.sendMessage(requestAuthPayload);
+
     return done.promise;
   }
 
@@ -116,53 +264,48 @@ export class SocketConnection {
   /**
    * listen to function requests
    */
-  listenToFunctionRequests() {
+  public listenToFunctionRequests() {
-    let done = plugins.smartpromise.defer();
+    const done = plugins.smartpromise.defer();
     if (this.authenticated) {
-      this.socket.on('function', (dataArg: ISocketRequestDataObject) => {
+      // Set up message handler for all messages
-        // check if requested function is available to the socket's scope
+      const messageHandler = (event: MessageEvent | { data: string }) => {
-        plugins.smartlog.defaultLogger.log('info', 'function request received');
+        try {
-        let referencedFunction: SocketFunction = this.role.allowedFunctions.find(
+          const data = typeof event.data === 'string' ? event.data : event.data.toString();
-          socketFunctionArg => {
+          const message: interfaces.ISocketMessage = JSON.parse(data);
-            return socketFunctionArg.name === dataArg.funcCallData.funcName;
+          this.handleMessage(message);
+        } catch (err) {
+          // Not a valid JSON message, ignore
         }
-        );
+      };
-        if (referencedFunction !== undefined) {
+
-          plugins.smartlog.defaultLogger.log('ok', 'function in access scope');
+      this.socket.addEventListener('message', messageHandler as any);
-          let localSocketRequest = new SocketRequest({
+
-            side: 'responding',
+      logger.log(
-            originSocketConnection: this,
-            shortId: dataArg.shortId,
-            funcCallData: dataArg.funcCallData
-          });
-          localSocketRequest.createResponse(); // takes care of creating response and sending it back
-        } else {
-          plugins.smartlog.defaultLogger.log(
-            'warn',
-            'function not existent or out of access scope'
-          );
-        }
-      });
-      this.socket.on('functionResponse', (dataArg: ISocketRequestDataObject) => {
-        plugins.smartlog.defaultLogger.log(
         'info',
-          `received response for request with id ${dataArg.shortId}`
+        `now listening to function requests for ${this.alias} on side ${this.side}`
-        );
-        let targetSocketRequest = helpers.getSocketRequestById(dataArg.shortId);
-        targetSocketRequest.handleResponse(dataArg);
-      });
-      plugins.smartlog.defaultLogger.log(
-        'info',
-        `now listening to function requests for ${this.alias}`
       );
       done.resolve(this);
     } else {
-      let errMessage: 'socket needs to be authenticated first';
+      const errMessage = 'socket needs to be authenticated first';
-      plugins.smartlog.defaultLogger.log('error', errMessage);
+      logger.log('error', errMessage);
       done.reject(errMessage);
     }
     return done.promise;
   }
 
-  // sending ----------------------
+  // disconnecting ----------------------
+  public async disconnect() {
+    if (this.socket.readyState === 1 || this.socket.readyState === 0) {
+      this.socket.close();
+    }
+    allSocketConnections.remove(this);
+    this.updateStatus('disconnected');
+  }
+
+  private updateStatus(statusArg: interfaces.TConnectionStatus) {
+    if (this.eventStatus !== statusArg) {
+      this.eventSubject.next(statusArg);
+    }
+    this.eventStatus = statusArg;
+  }
 }

ts/smartsocket.classes.socketfunction.ts

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

ts/smartsocket.classes.socketrequest.ts

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

ts/smartsocket.classes.socketrole.ts

@@ -1,29 +0,0 @@
-import * as plugins from './smartsocket.plugins';
-
-// import classes
-import { Objectmap } from '@pushrocks/lik';
-import { SocketFunction } from './smartsocket.classes.socketfunction';
-
-/**
- * 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;
-  allowedFunctions = new Objectmap<SocketFunction>();
-  constructor(optionsArg: SocketRoleOptions) {
-    this.name = optionsArg.name;
-    this.passwordHash = optionsArg.passwordHash;
-  }
-  addSocketFunction(socketFunctionArg: SocketFunction) {
-    this.allowedFunctions.add(socketFunctionArg);
-  }
-}

ts/smartsocket.classes.socketserver.ts

@@ -1,76 +1,203 @@
-import * as plugins from './smartsocket.plugins';
+import * as plugins from './smartsocket.plugins.js';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';
 
 // used in case no other server is supplied
-import * as http from 'http';
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
-import { Smartsocket } from './smartsocket.classes.smartsocket';
+import { logger } from './smartsocket.logging.js';
 
 /**
- * class socketServer
+ * class SocketServer
- * handles the attachment of socketIo to whatever server is in play
+ * handles the WebSocket server in standalone mode, or provides hooks for smartserve integration
  */
 export class SocketServer {
   private smartsocket: Smartsocket;
-  private httpServer: http.Server;
+  private httpServer: pluginsTyped.http.Server | pluginsTyped.https.Server;
-  // wether httpServer is standalone
+  private wsServer: pluginsTyped.ws.WebSocketServer;
+
+  /**
+   * whether httpServer is standalone (created by us)
+   */
   private standaloneServer = false;
-  private expressServer: any;
 
   constructor(smartSocketInstance: Smartsocket) {
     this.smartsocket = smartSocketInstance;
   }
 
   /**
-   * starts the server with another server
+   * Starts listening to incoming websocket connections (standalone mode).
-   * also works with an express style server
+   * If no port is specified, this is a no-op (hooks mode via smartserve).
-   */
-  public async setExternalServer(serverType: 'express' | 'http', serverArg: any) {
-    if (serverType === 'http') {
-      this.httpServer = serverArg;
-    } else if (serverType === 'express') {
-      this.expressServer = serverArg;
-    }
-  }
-
-  /**
-   * gets the server for socket.io
-   */
-  public getServerForSocketIo() {
-    if (this.httpServer) {
-      return this.httpServer;
-    } else if (this.expressServer) {
-      return this.expressServer;
-    } else if (!this.httpServer && !this.expressServer) {
-      this.httpServer = new http.Server();
-      this.standaloneServer = true;
-      return this.httpServer;
-    } else {
-      throw new Error('no server specified!');
-    }
-  }
-
-  /**
-   * starts listening to incoming sockets:
    */
   public async start() {
-    const done = plugins.smartpromise.defer();
+    // If no port specified, we're in hooks mode - nothing to start
-
+    if (!this.smartsocket.options.port) {
-    // handle http servers
+      return;
-    if (this.httpServer && this.standaloneServer) {
-      this.httpServer.listen(this.smartsocket.options.port, () => {
-        console.log(`Server started in standalone mode on ${this.smartsocket.options.port}`);
-        done.resolve();
-      });
-    } else {
-      done.resolve();
     }
 
-    // nothing else to do if express server is set
+    // Standalone mode - create our own HTTP server and WebSocket server
+    const done = plugins.smartpromise.defer();
+    const httpModule = await this.smartsocket.smartenv.getSafeNodeModule('http');
+    const wsModule = await this.smartsocket.smartenv.getSafeNodeModule('ws');
+
+    this.httpServer = httpModule.createServer();
+    this.standaloneServer = true;
+
+    // Create WebSocket server attached to HTTP server
+    this.wsServer = new wsModule.WebSocketServer({ server: this.httpServer });
+
+    this.wsServer.on('connection', (ws: pluginsTyped.ws.WebSocket) => {
+      this.smartsocket.handleNewConnection(ws);
+    });
+
+    this.httpServer.listen(this.smartsocket.options.port, () => {
+      logger.log(
+        'success',
+        `Server started in standalone mode on port ${this.smartsocket.options.port}`
+      );
+      done.resolve();
+    });
+
     await done.promise;
-    return;
   }
 
   /**
    * closes the server
    */
-  public async stop() {}
+  public async stop() {
+    const done = plugins.smartpromise.defer<void>();
+    let resolved = false;
+
+    if (this.wsServer) {
+      // Close all WebSocket connections
+      this.wsServer.clients.forEach((client) => {
+        client.terminate();
+      });
+      this.wsServer.close();
+      this.wsServer = null;
+    }
+
+    if (this.httpServer && this.standaloneServer) {
+      const resolveOnce = () => {
+        if (!resolved) {
+          resolved = true;
+          this.httpServer = null;
+          this.standaloneServer = false;
+          done.resolve();
+        }
+      };
+
+      this.httpServer.close(() => {
+        resolveOnce();
+      });
+
+      // Add a timeout in case close callback doesn't fire
+      const timeoutId = setTimeout(() => {
+        resolveOnce();
+      }, 2000);
+
+      // Ensure timeout doesn't keep process alive
+      if (timeoutId.unref) {
+        timeoutId.unref();
+      }
+    } else {
+      done.resolve();
+    }
+
+    await done.promise;
+  }
+
+  /**
+   * Returns WebSocket hooks for integration with smartserve.
+   * Pass these hooks to SmartServe's websocket config.
+   */
+  public getSmartserveWebSocketHooks(): pluginsTyped.ISmartserveWebSocketHooks {
+    return {
+      onOpen: async (peer: pluginsTyped.ISmartserveWebSocketPeer) => {
+        // Create a wrapper that adapts ISmartserveWebSocketPeer to WebSocket-like interface
+        const wsLikeSocket = this.createWsLikeFromPeer(peer);
+        await this.smartsocket.handleNewConnection(wsLikeSocket as any);
+      },
+      onMessage: async (peer: pluginsTyped.ISmartserveWebSocketPeer, message: pluginsTyped.ISmartserveWebSocketMessage) => {
+        // Dispatch message to the SocketConnection via the adapter
+        const adapter = peer.data.get('smartsocket_adapter') as any;
+        if (adapter) {
+          let textData: string | undefined;
+          if (message.type === 'text' && message.text) {
+            textData = message.text;
+          } else if (message.type === 'binary' && message.data) {
+            // Convert binary to text (Buffer/Uint8Array to string)
+            textData = new TextDecoder().decode(message.data);
+          }
+          if (textData) {
+            adapter.dispatchMessage(textData);
+          }
+        }
+      },
+      onClose: async (peer: pluginsTyped.ISmartserveWebSocketPeer, code: number, reason: string) => {
+        // Dispatch close to the SocketConnection via the adapter
+        const adapter = peer.data.get('smartsocket_adapter') as any;
+        if (adapter) {
+          adapter.dispatchClose();
+        }
+      },
+      onError: async (peer: pluginsTyped.ISmartserveWebSocketPeer, error: Error) => {
+        // Dispatch error to the SocketConnection via the adapter
+        const adapter = peer.data.get('smartsocket_adapter') as any;
+        if (adapter) {
+          adapter.dispatchError();
+        }
+      },
+    };
+  }
+
+  /**
+   * Creates a WebSocket-like object from a smartserve peer
+   * This allows our SocketConnection to work with both native WebSocket and smartserve peers
+   */
+  private createWsLikeFromPeer(peer: pluginsTyped.ISmartserveWebSocketPeer): any {
+    const messageListeners: Array<(event: any) => void> = [];
+    const closeListeners: Array<() => void> = [];
+    const errorListeners: Array<() => void> = [];
+
+    // Store the adapter on the peer for message routing
+    peer.data.set('smartsocket_adapter', {
+      dispatchMessage: (data: string) => {
+        messageListeners.forEach((listener) => {
+          listener({ data });
+        });
+      },
+      dispatchClose: () => {
+        closeListeners.forEach((listener) => listener());
+      },
+      dispatchError: () => {
+        errorListeners.forEach((listener) => listener());
+      },
+    });
+
+    return {
+      readyState: peer.readyState,
+      send: (data: string) => peer.send(data),
+      close: (code?: number, reason?: string) => peer.close(code, reason),
+      addEventListener: (event: string, listener: any) => {
+        if (event === 'message') {
+          messageListeners.push(listener);
+        } else if (event === 'close') {
+          closeListeners.push(listener);
+        } else if (event === 'error') {
+          errorListeners.push(listener);
+        }
+      },
+      removeEventListener: (event: string, listener: any) => {
+        if (event === 'message') {
+          const idx = messageListeners.indexOf(listener);
+          if (idx >= 0) messageListeners.splice(idx, 1);
+        } else if (event === 'close') {
+          const idx = closeListeners.indexOf(listener);
+          if (idx >= 0) closeListeners.splice(idx, 1);
+        } else if (event === 'error') {
+          const idx = errorListeners.indexOf(listener);
+          if (idx >= 0) errorListeners.splice(idx, 1);
+        }
+      },
+    };
+  }
 }

ts/smartsocket.helpers.ts

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

ts/smartsocket.logging.ts

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

ts/smartsocket.plugins.ts

@@ -1,10 +1,29 @@
-import * as lik from '@pushrocks/lik';
+// apiglobal scope
-import * as smartlog from '@pushrocks/smartlog';
+import * as typedrequestInterfaces from '@api.global/typedrequest-interfaces';
-import * as smarthash from '@pushrocks/smarthash';
-import * as smartdelay from '@pushrocks/smartdelay';
-import * as smartpromise from '@pushrocks/smartpromise';
-import * as shortid from 'shortid';
-import * as socketIo from 'socket.io';
-import * as socketIoClient from 'socket.io-client';
 
-export { lik, smartlog, smarthash, smartdelay, smartpromise, shortid, socketIo, socketIoClient };
+export { typedrequestInterfaces };
+
+// pushrocks scope
+import * as isohash from '@push.rocks/isohash';
+import * as isounique from '@push.rocks/isounique';
+import * as lik from '@push.rocks/lik';
+import * as smartenv from '@push.rocks/smartenv';
+import * as smartjson from '@push.rocks/smartjson';
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smarttime from '@push.rocks/smarttime';
+import * as smartrx from '@push.rocks/smartrx';
+
+export {
+  isohash,
+  isounique,
+  lik,
+  smartenv,
+  smartjson,
+  smartlog,
+  smartdelay,
+  smartpromise,
+  smarttime,
+  smartrx,
+};

ts/smartsocket.pluginstyped.ts

@@ -0,0 +1,46 @@
+// node native
+import type * as http from 'http';
+import type * as https from 'https';
+
+export type { http, https };
+
+// third party scope - ws types
+import type * as wsTypes from 'ws';
+
+export namespace ws {
+  export type WebSocket = wsTypes.WebSocket;
+  export type WebSocketServer = wsTypes.WebSocketServer;
+  export type RawData = wsTypes.RawData;
+}
+
+// smartserve compatibility interface (for setExternalServer)
+// This mirrors the IWebSocketPeer interface from smartserve
+export interface ISmartserveWebSocketPeer {
+  id: string;
+  url: string;
+  readyState: 0 | 1 | 2 | 3;
+  protocol: string;
+  extensions: string;
+  send(data: string): void;
+  sendBinary(data: Uint8Array | ArrayBuffer): void;
+  close(code?: number, reason?: string): void;
+  ping(data?: Uint8Array): void;
+  terminate(): void;
+  context: any;
+  data: Map<string, unknown>;
+  tags: Set<string>;
+}
+
+export interface ISmartserveWebSocketMessage {
+  type: 'text' | 'binary';
+  text?: string;
+  data?: Uint8Array;
+  size: number;
+}
+
+export interface ISmartserveWebSocketHooks {
+  onOpen?: (peer: ISmartserveWebSocketPeer) => void | Promise<void>;
+  onMessage?: (peer: ISmartserveWebSocketPeer, message: ISmartserveWebSocketMessage) => void | Promise<void>;
+  onClose?: (peer: ISmartserveWebSocketPeer, code: number, reason: string) => void | Promise<void>;
+  onError?: (peer: ISmartserveWebSocketPeer, error: Error) => void | Promise<void>;
+}

tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": true
+  },
+  "exclude": [
+    "dist_*/**/*.d.ts"
+  ]
+}

tslint.json

@@ -1,17 +0,0 @@
-{
-  "extends": ["tslint:latest", "tslint-config-prettier"],
-  "rules": {
-    "semicolon": [true, "always"],
-    "no-console": false,
-    "ordered-imports": false,
-    "object-literal-sort-keys": false,
-    "member-ordering": {
-      "options":{
-        "order": [
-          "static-method"
-        ]
-      }
-    }
-  },
-  "defaultSeverity": "warning"
-}