@push.rocks/smartsocket 2.0.19

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@push.rocks/smartsocket",
+  "version": "2.0.19",
+  "description": "easy and secure websocket communication",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "test": "(tstest test/)",
+    "build": "(tsbuild --web --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"
+  },
+  "author": "Lossless GmbH",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://gitlab.com/pushrocks/smartsocket/issues"
+  },
+  "homepage": "https://gitlab.com/pushrocks/smartsocket#README",
+  "dependencies": {
+    "@apiglobal/typedrequest-interfaces": "^2.0.1",
+    "@pushrocks/isohash": "^2.0.0",
+    "@pushrocks/isounique": "^1.0.5",
+    "@pushrocks/lik": "^6.0.2",
+    "@pushrocks/smartdelay": "^2.0.13",
+    "@pushrocks/smartenv": "^5.0.5",
+    "@pushrocks/smartexpress": "^4.0.34",
+    "@pushrocks/smartjson": "^5.0.1",
+    "@pushrocks/smartlog": "^3.0.1",
+    "@pushrocks/smartpromise": "^3.1.7",
+    "@pushrocks/smartrx": "^3.0.0",
+    "@pushrocks/smarttime": "^4.0.1",
+    "engine.io": "6.3.1",
+    "socket.io": "4.5.4",
+    "socket.io-client": "4.5.4"
+  },
+  "devDependencies": {
+    "@gitzone/tsbuild": "^2.1.63",
+    "@gitzone/tsbundle": "^2.0.7",
+    "@gitzone/tsrun": "^1.2.37",
+    "@gitzone/tstest": "^1.0.72",
+    "@pushrocks/tapbundle": "^5.0.4",
+    "@types/node": "^18.15.11"
+  },
+  "private": false,
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ]
+}

package/readme.md

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

package/ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@pushrocks/smartsocket',
+  version: '2.0.19',
+  description: 'easy and secure websocket communication'
+}

package/ts/index.ts

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

package/ts/interfaces/connection.ts

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

package/ts/interfaces/index.ts

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

package/ts/interfaces/tag.ts

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

package/ts/smartsocket.classes.smartsocket.ts

@@ -0,0 +1,137 @@
+import * as plugins from './smartsocket.plugins.js';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';
+import * as interfaces from './interfaces/index.js';
+
+// classes
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
+import {
+  ISocketFunctionCallDataRequest,
+  SocketFunction,
+  ISocketFunctionCallDataResponse,
+} from './smartsocket.classes.socketfunction.js';
+import { SocketRequest } from './smartsocket.classes.socketrequest.js';
+import { SocketServer } from './smartsocket.classes.socketserver.js';
+
+import { logger } from './smartsocket.logging.js';
+
+export interface ISmartsocketConstructorOptions {
+  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: pluginsTyped.socketIo.Server;
+  public socketConnections = new plugins.lik.ObjectMap<SocketConnection>();
+  public socketFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
+  public socketRequests = new plugins.lik.ObjectMap<SocketRequest<any>>();
+
+  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);
+  }
+
+  public async setExternalServer(serverType: 'smartexpress', serverArg: any) {
+    await this.socketServer.setExternalServer(serverType, serverArg);
+  }
+
+  /**
+   * starts smartsocket
+   */
+  public async start() {
+    const socketIoModule = await this.smartenv.getSafeNodeModule('socket.io');
+    this.io = new socketIoModule.Server(await this.socketServer.getServerForSocketIo(), {
+      cors: {
+        allowedHeaders: '*',
+        methods: '*',
+        origin: '*',
+      }
+    });
+    await this.socketServer.start();
+    this.io.on('connection', (socketArg) => {
+      this._handleSocketConnection(socketArg);
+    });
+  }
+
+  /**
+   * stops smartsocket
+   */
+  public async stop() {
+    await plugins.smartdelay.delayFor(1000);
+    this.socketConnections.forEach((socketObjectArg: SocketConnection) => {
+      if (socketObjectArg) {
+        logger.log(
+          'info',
+          `disconnecting socket with >>alias ${socketObjectArg.alias} due to server stop...`
+        );
+        socketObjectArg.disconnect();
+      }
+    });
+    this.socketConnections.wipe();
+    this.io.close();
+
+    // stop the corresponging server
+    this.socketServer.stop();
+  }
+
+  // communication
+
+  /**
+   * allows call to specific client.
+   */
+  public async clientCall<T extends plugins.typedrequestInterfaces.ITypedRequest>(
+    functionNameArg: T['method'],
+    dataArg: T['request'],
+    targetSocketConnectionArg: SocketConnection
+  ): Promise<T['response']> {
+    const socketRequest = new SocketRequest<T>(this, {
+      funcCallData: {
+        funcDataArg: dataArg,
+        funcName: functionNameArg,
+      },
+      originSocketConnection: targetSocketConnectionArg,
+      shortId: plugins.isounique.uni(),
+      side: 'requesting',
+    });
+    const response: ISocketFunctionCallDataResponse<T> = await socketRequest.dispatch();
+    const result = response.funcDataArg;
+    return result;
+  }
+
+  public addSocketFunction(socketFunction: SocketFunction<any>) {
+    this.socketFunctions.add(socketFunction);
+  }
+
+  /**
+   * the standard handler for new socket connections
+   */
+  private async _handleSocketConnection(socketArg: pluginsTyped.socketIo.Socket) {
+    const socketConnection: SocketConnection = new SocketConnection({
+      alias: undefined,
+      authenticated: false,
+      side: 'server',
+      smartsocketHost: this,
+      socket: socketArg,
+    });
+    logger.log('info', 'Socket connected. Trying to authenticate...');
+    this.socketConnections.add(socketConnection);
+    const disconnectSubscription = socketConnection.eventSubject.subscribe((eventArg) => {
+      if (eventArg === 'disconnected') {
+        this.socketConnections.remove(socketConnection);
+        disconnectSubscription.unsubscribe();
+      }
+    });
+    await socketConnection.authenticate();
+    await socketConnection.listenToFunctionRequests();
+    await socketConnection.socket.emit('serverFullyReactive');
+  }
+}

package/ts/smartsocket.classes.smartsocketclient.ts

@@ -0,0 +1,266 @@
+import * as plugins from './smartsocket.plugins.js';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';
+import * as interfaces from './interfaces/index.js';
+
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
+import {
+  ISocketFunctionCallDataRequest,
+  SocketFunction,
+} from './smartsocket.classes.socketfunction.js';
+import { ISocketRequestDataObject, SocketRequest } from './smartsocket.classes.socketrequest.js';
+import { logger } from './smartsocket.logging.js';
+
+/**
+ * interface for class SmartsocketClient
+ */
+export interface ISmartsocketClientOptions {
+  port: number;
+  url: string;
+  alias: string; // an alias makes it easier to identify this client in a multo client environment
+  autoReconnect?: boolean;
+}
+
+export class SmartsocketClient {
+  // a unique id
+  public shortId = plugins.isounique.uni();
+
+  // the shortId of the remote we connect to
+  public remoteShortId: string = null;
+
+  public alias: string;
+  public socketConnection: SocketConnection;
+  public serverUrl: string;
+  public serverPort: number;
+  public autoReconnect: boolean;
+
+  // status handling
+  public eventSubject = new plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>();
+  public eventStatus: interfaces.TConnectionStatus = 'new';
+
+  public socketFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
+  public socketRequests = new plugins.lik.ObjectMap<SocketRequest<any>>();
+
+  // tagStore
+  private tagStore: { [key: string]: interfaces.ITag } = {};
+  private tagStoreSubscription: plugins.smartrx.rxjs.Subscription;
+
+  /**
+   * adds a tag to a connection
+   */
+  public async addTag(tagArg: interfaces.ITag) {
+    if (this.socketConnection) {
+      await this.socketConnection.addTag(tagArg);
+    } else {
+      this.tagStore[tagArg.id] = tagArg;
+    }
+  }
+
+  /**
+   * gets a tag by id
+   * @param tagIdArg
+   */
+  public async getTagById(tagIdArg: interfaces.ITag['id']) {
+    return this.tagStore[tagIdArg];
+  }
+
+  /**
+   * removes a tag from a connection
+   */
+  public async removeTagById(tagIdArg: interfaces.ITag['id']) {
+    if (this.socketConnection) {
+      this.socketConnection.removeTagById(tagIdArg);
+    } else {
+      delete this.tagStore[tagIdArg];
+    }
+  }
+
+  constructor(optionsArg: ISmartsocketClientOptions) {
+    this.alias = optionsArg.alias;
+    this.serverUrl = optionsArg.url;
+    this.serverPort = optionsArg.port;
+    this.autoReconnect = optionsArg.autoReconnect;
+  }
+
+  public addSocketFunction(socketFunction: SocketFunction<any>) {
+    this.socketFunctions.add(socketFunction);
+  }
+
+  /**
+   * connect the client to the server
+   */
+  public async connect() {
+    const done = plugins.smartpromise.defer();
+    const smartenvInstance = new plugins.smartenv.Smartenv();
+    const socketIoClient: any = await smartenvInstance.getEnvAwareModule({
+      nodeModuleName: 'socket.io-client',
+      webUrlArg: 'https://cdn.jsdelivr.net/npm/socket.io-client@4/dist/socket.io.js',
+      getFunction: () => {
+        const socketIoBrowserModule = (globalThis as any).io;
+        // console.log('loaded socket.io for browser');
+        return socketIoBrowserModule;
+      },
+    });
+    // console.log(socketIoClient);
+    logger.log('info', 'trying to connect...');
+    const socketUrl = `${this.serverUrl}:${this.serverPort}`;
+    this.socketConnection = new SocketConnection({
+      alias: this.alias,
+      authenticated: false,
+      side: 'client',
+      smartsocketHost: this,
+      socket: await socketIoClient
+        .connect(socketUrl, {
+          multiplex: true,
+          rememberUpgrade: true,
+          autoConnect: false,
+          reconnectionAttempts: 0,
+          rejectUnauthorized: socketUrl.startsWith('https://localhost') ? false : true,
+        })
+        .open(),
+    });
+
+    const timer = new plugins.smarttime.Timer(5000);
+    timer.start();
+    timer.completed.then(() => {
+      this.updateStatus('timedOut');
+      logger.log('warn', 'connection to server timed out.');
+      this.disconnect(true);
+    });
+
+    // authentication flow
+    this.socketConnection.socket.on('requestAuth', (dataArg: interfaces.IRequestAuthPayload) => {
+      timer.reset();
+      logger.log('info', `server ${dataArg.serverAlias} requested authentication`);
+
+      // lets register the authenticated event
+      this.socketConnection.socket.on('authenticated', async () => {
+        this.remoteShortId = dataArg.serverAlias;
+        logger.log('info', 'client is authenticated');
+        this.socketConnection.authenticated = true;
+        await this.socketConnection.listenToFunctionRequests();
+      });
+
+      this.socketConnection.socket.on('serverFullyReactive', async () => {
+        // lets take care of retagging
+        const oldTagStore = this.tagStore;
+        this.tagStoreSubscription?.unsubscribe();
+        for (const keyArg of Object.keys(this.tagStore)) {
+          this.socketConnection.addTag(this.tagStore[keyArg]);
+        }
+        this.tagStoreSubscription = this.socketConnection.tagStoreObservable.subscribe(
+          (tagStoreArg) => {
+            this.tagStore = tagStoreArg;
+          }
+        );
+
+        for (const tag of Object.keys(oldTagStore)) {
+          await this.addTag(oldTagStore[tag]);
+        }
+        this.updateStatus('connected');
+        done.resolve();
+      });
+
+      // lets register the forbidden event
+      this.socketConnection.socket.on('forbidden', async () => {
+        logger.log('warn', `disconnecting due to being forbidden to use the ressource`);
+        await this.disconnect();
+      });
+
+      // lets provide the actual auth data
+      this.socketConnection.socket.emit('dataAuth', {
+        alias: this.alias,
+      });
+    });
+
+    // handle connection
+    this.socketConnection.socket.on('connect', async () => {});
+
+    // handle disconnection and errors
+    this.socketConnection.socket.on('disconnect', async () => {
+      await this.disconnect(true);
+    });
+
+    this.socketConnection.socket.on('reconnect_failed', async () => {
+      await this.disconnect(true);
+    });
+    this.socketConnection.socket.on('connect_error', async () => {
+      await this.disconnect(true);
+    });
+    return done.promise;
+  }
+
+  private disconnectRunning = false;
+
+  /**
+   * disconnect from the server
+   */
+  public async disconnect(useAutoReconnectSetting = false) {
+    if (this.disconnectRunning) {
+      return;
+    }
+    this.disconnectRunning = true;
+    this.updateStatus('disconnecting');
+    this.tagStoreSubscription?.unsubscribe();
+    if (this.socketConnection) {
+      await this.socketConnection.disconnect();
+      this.socketConnection = undefined;
+      logger.log('ok', 'disconnected socket!');
+    } else {
+      this.disconnectRunning = false;
+      logger.log('warn', 'tried to disconnect, without a SocketConnection');
+      return;
+    }
+
+    logger.log('warn', `disconnected from server ${this.remoteShortId}`);
+    this.remoteShortId = null;
+
+    if (this.autoReconnect && useAutoReconnectSetting && this.eventStatus !== 'connecting') {
+      this.updateStatus('connecting');
+      console.log('debounced reconnect!');
+      await plugins.smartdelay.delayForRandom(10000, 20000);
+      this.disconnectRunning = false;
+      await this.connect();
+    } else {
+      this.disconnectRunning = false;
+    }
+  }
+
+  /**
+   * stops the client completely
+   */
+  public async stop() {
+    this.autoReconnect = false;
+    await this.disconnect();
+  }
+
+  /**
+   * dispatches a server call
+   * @param functionNameArg
+   * @param dataArg
+   */
+  public async serverCall<T extends plugins.typedrequestInterfaces.ITypedRequest>(
+    functionNameArg: T['method'],
+    dataArg: T['request']
+  ): Promise<T['response']> {
+    const done = plugins.smartpromise.defer();
+    const socketRequest = new SocketRequest<T>(this, {
+      side: 'requesting',
+      originSocketConnection: this.socketConnection,
+      shortId: plugins.isounique.uni(),
+      funcCallData: {
+        funcName: functionNameArg,
+        funcDataArg: dataArg,
+      },
+    });
+    const response = await socketRequest.dispatch();
+    const result = response.funcDataArg;
+    return result;
+  }
+
+  private updateStatus(statusArg: interfaces.TConnectionStatus) {
+    if (this.eventStatus !== statusArg) {
+      this.eventSubject.next(statusArg);
+    }
+    this.eventStatus = statusArg;
+  }
+}