@push.rocks/smartsocket 2.0.19

package/ts/smartsocket.classes.socketconnection.ts

@@ -0,0 +1,224 @@
+import * as plugins from './smartsocket.plugins.js';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';
+import * as interfaces from './interfaces/index.js';
+
+// import classes
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
+import { SocketFunction } from './smartsocket.classes.socketfunction.js';
+import { SocketRequest, ISocketRequestDataObject } from './smartsocket.classes.socketrequest.js';
+
+// socket.io
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient.js';
+import { logger } from './smartsocket.logging.js';
+
+// export interfaces
+
+/**
+ * defines is a SocketConnection is server or client side. Important for mesh setups.
+ */
+export type TSocketConnectionSide = 'server' | 'client';
+
+/**
+ * interface for constructor of class SocketConnection
+ */
+export interface ISocketConnectionConstructorOptions {
+  alias: string;
+  authenticated: boolean;
+  side: TSocketConnectionSide;
+  smartsocketHost: Smartsocket | SmartsocketClient;
+  socket: pluginsTyped.socketIo.Socket | pluginsTyped.socketIoClient.Socket;
+}
+
+/**
+ * interface for authentication data
+ */
+export interface ISocketConnectionAuthenticationObject {
+  alias: string;
+}
+
+// export classes
+export let allSocketConnections = new plugins.lik.ObjectMap<SocketConnection>();
+
+/**
+ * class SocketConnection represents a websocket connection
+ */
+export class SocketConnection {
+  public alias: string;
+  public side: TSocketConnectionSide;
+  public authenticated: boolean = false;
+  public smartsocketRef: Smartsocket | SmartsocketClient;
+  public socket: pluginsTyped.socketIo.Socket | pluginsTyped.socketIoClient.Socket;
+
+  public eventSubject = new plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>();
+  public eventStatus: interfaces.TConnectionStatus = 'new';
+
+  private tagStore: interfaces.TTagStore = {};
+  public tagStoreObservable = new plugins.smartrx.rxjs.Subject<interfaces.TTagStore>();
+  public remoteTagStoreObservable = new plugins.smartrx.rxjs.Subject<interfaces.TTagStore>();
+
+  constructor(optionsArg: ISocketConnectionConstructorOptions) {
+    this.alias = optionsArg.alias;
+    this.authenticated = optionsArg.authenticated;
+    this.side = optionsArg.side;
+    this.smartsocketRef = optionsArg.smartsocketHost;
+    this.socket = optionsArg.socket;
+
+    // standard behaviour that is always true
+    allSocketConnections.add(this);
+
+    // handle connection
+    this.socket.on('connect', async () => {
+      this.updateStatus('connected');
+    });
+    this.socket.on('disconnect', async () => {
+      logger.log(
+        'info',
+        `SocketConnection with >alias ${this.alias} on >side ${this.side} disconnected`
+      );
+      await this.disconnect();
+      allSocketConnections.remove(this);
+      this.eventSubject.next('disconnected');
+    });
+  }
+
+  /**
+   * adds a tag to a connection
+   */
+  public async addTag(tagArg: interfaces.ITag) {
+    const done = plugins.smartpromise.defer();
+    this.tagStore[tagArg.id] = tagArg;
+    this.tagStoreObservable.next(this.tagStore);
+    const remoteSubscription = this.remoteTagStoreObservable.subscribe((remoteTagStore) => {
+      if (!remoteTagStore[tagArg.id]) {
+        return;
+      }
+      const localTagString = plugins.smartjson.stringify(tagArg);
+      const remoteTagString = plugins.smartjson.stringify(remoteTagStore[tagArg.id]);
+      if (localTagString === remoteTagString) {
+        remoteSubscription.unsubscribe();
+        done.resolve();
+      }
+    });
+    this.socket.emit('updateTagStore', this.tagStore);
+    await done.promise;
+  }
+
+  /**
+   * gets a tag by id
+   * @param tagIdArg
+   */
+  public async getTagById(tagIdArg: interfaces.ITag['id']) {
+    return this.tagStore[tagIdArg];
+  }
+
+  /**
+   * removes a tag from a connection
+   */
+  public async removeTagById(tagIdArg: interfaces.ITag['id']) {
+    delete this.tagStore[tagIdArg];
+    this.tagStoreObservable.next(this.tagStore);
+    this.socket.emit('updateTagStore', this.tagStore);
+  }
+
+  // authenticating --------------------------
+
+  /**
+   * authenticate the socket
+   */
+  public authenticate() {
+    const done = plugins.smartpromise.defer();
+    this.socket.on('dataAuth', async (dataArg: ISocketConnectionAuthenticationObject) => {
+      logger.log('info', 'received authentication data...');
+      this.socket.removeAllListeners('dataAuth');
+      if (dataArg.alias) {
+        // TODO: authenticate password
+        this.alias = dataArg.alias;
+        this.authenticated = true;
+        this.socket.emit('authenticated');
+        logger.log('ok', `socket with >>alias ${this.alias} is authenticated!`);
+        done.resolve(this);
+      } else {
+        this.authenticated = false;
+        await this.disconnect();
+        done.reject('a socket tried to connect, but could not authenticated.');
+      }
+    });
+    const requestAuthPayload: interfaces.IRequestAuthPayload = {
+      serverAlias: this.smartsocketRef.alias,
+    };
+    this.socket.emit('requestAuth', requestAuthPayload);
+    return done.promise;
+  }
+
+  // listening -------------------------------
+
+  /**
+   * listen to function requests
+   */
+  public listenToFunctionRequests() {
+    const done = plugins.smartpromise.defer();
+    if (this.authenticated) {
+      this.socket.on('function', (dataArg: ISocketRequestDataObject<any>) => {
+        // check if requested function is available to the socket's scope
+        // logger.log('info', 'function request received');
+        const referencedFunction: SocketFunction<any> =
+          this.smartsocketRef.socketFunctions.findSync((socketFunctionArg) => {
+            return socketFunctionArg.name === dataArg.funcCallData.funcName;
+          });
+        if (referencedFunction) {
+          // logger.log('ok', 'function in access scope');
+          const localSocketRequest = new SocketRequest(this.smartsocketRef, {
+            side: 'responding',
+            originSocketConnection: this,
+            shortId: dataArg.shortId,
+            funcCallData: dataArg.funcCallData,
+          });
+          localSocketRequest.createResponse(); // takes care of creating response and sending it back
+        } else {
+          logger.log('warn', 'function not existent or out of access scope');
+        }
+      });
+      this.socket.on('functionResponse', (dataArg: ISocketRequestDataObject<any>) => {
+        // logger.log('info', `received response for request with id ${dataArg.shortId}`);
+        const targetSocketRequest = SocketRequest.getSocketRequestById(
+          this.smartsocketRef,
+          dataArg.shortId
+        );
+        targetSocketRequest.handleResponse(dataArg);
+      });
+
+      this.socket.on('updateTagStore', async (tagStoreArg: interfaces.TTagStore) => {
+        if (!plugins.smartjson.deepEqualObjects(this.tagStore, tagStoreArg)) {
+          this.tagStore = tagStoreArg;
+          this.socket.emit('updateTagStore', this.tagStore);
+          this.tagStoreObservable.next(this.tagStore);
+        }
+        this.remoteTagStoreObservable.next(tagStoreArg);
+      });
+
+      logger.log(
+        'info',
+        `now listening to function requests for ${this.alias} on side ${this.side}`
+      );
+      done.resolve(this);
+    } else {
+      const errMessage = 'socket needs to be authenticated first';
+      logger.log('error', errMessage);
+      done.reject(errMessage);
+    }
+    return done.promise;
+  }
+
+  // disconnecting ----------------------
+  public async disconnect() {
+    this.socket.disconnect(true);
+    this.updateStatus('disconnected');
+  }
+
+  private updateStatus(statusArg: interfaces.TConnectionStatus) {
+    if (this.eventStatus !== statusArg) {
+      this.eventSubject.next(statusArg);
+    }
+    this.eventStatus = statusArg;
+  }
+}

package/ts/smartsocket.classes.socketfunction.ts

@@ -0,0 +1,93 @@
+import * as plugins from './smartsocket.plugins.js';
+
+// import classes
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient.js';
+
+// export interfaces
+
+/**
+ * interface of the contructor options of class SocketFunction
+ */
+export interface ISocketFunctionConstructorOptions<
+  T extends plugins.typedrequestInterfaces.ITypedRequest
+> {
+  funcName: T['method'];
+  funcDef: TFuncDef<T>;
+}
+
+/**
+ * interface of the Socket Function call, in other words the object that routes a call to a function
+ */
+export interface ISocketFunctionCallDataRequest<
+  T extends plugins.typedrequestInterfaces.ITypedRequest
+> {
+  funcName: T['method'];
+  funcDataArg: T['request'];
+}
+
+/**
+ * interface of the Socket Function call, in other words the object that routes a call to a function
+ */
+export interface ISocketFunctionCallDataResponse<
+  T extends plugins.typedrequestInterfaces.ITypedRequest
+> {
+  funcName: T['method'];
+  funcDataArg: T['response'];
+}
+
+/**
+ * interface for function definition of SocketFunction
+ */
+export type TFuncDef<T extends plugins.typedrequestInterfaces.ITypedRequest> = (
+  dataArg: T['request'],
+  connectionArg: SocketConnection
+) => PromiseLike<T['response']>;
+
+// export classes
+
+/**
+ * class that respresents a function that can be transparently called using a SocketConnection
+ */
+export class SocketFunction<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+  // STATIC
+  public static getSocketFunctionByName<Q extends plugins.typedrequestInterfaces.ITypedRequest>(
+    smartsocketRefArg: Smartsocket | SmartsocketClient,
+    functionNameArg: string
+  ): SocketFunction<Q> {
+    return smartsocketRefArg.socketFunctions.findSync((socketFunctionArg) => {
+      return socketFunctionArg.name === functionNameArg;
+    });
+  }
+
+  // INSTANCE
+  public name: string;
+  public funcDef: TFuncDef<T>;
+
+  /**
+   * the constructor for SocketFunction
+   */
+  constructor(optionsArg: ISocketFunctionConstructorOptions<T>) {
+    this.name = optionsArg.funcName;
+    this.funcDef = optionsArg.funcDef;
+  }
+
+  /**
+   * invokes the function of this SocketFunction
+   */
+  public async invoke(
+    dataArg: ISocketFunctionCallDataRequest<T>,
+    socketConnectionArg: SocketConnection
+  ): Promise<ISocketFunctionCallDataResponse<T>> {
+    if (dataArg.funcName === this.name) {
+      const funcResponseData: ISocketFunctionCallDataResponse<T> = {
+        funcName: this.name,
+        funcDataArg: await this.funcDef(dataArg.funcDataArg, socketConnectionArg),
+      };
+      return funcResponseData;
+    } else {
+      throw new Error("SocketFunction.name does not match the data argument's .name!");
+    }
+  }
+}

package/ts/smartsocket.classes.socketrequest.ts

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

package/ts/smartsocket.classes.socketserver.ts

@@ -0,0 +1,94 @@
+import * as plugins from './smartsocket.plugins.js';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';
+
+// used in case no other server is supplied
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
+import { logger } from './smartsocket.logging.js';
+
+/**
+ * class socketServer
+ * handles the attachment of socketIo to whatever server is in play
+ */
+export class SocketServer {
+  private smartsocket: Smartsocket;
+  private httpServerDeferred: plugins.smartpromise.Deferred<any>;
+  private httpServer: pluginsTyped.http.Server | pluginsTyped.https.Server;
+
+  /**
+   * wether httpServer is standalone
+   */
+  private standaloneServer = false;
+
+  constructor(smartSocketInstance: Smartsocket) {
+    this.smartsocket = smartSocketInstance;
+  }
+
+  /**
+   * starts the server with another server
+   * also works with an express style server
+   */
+  public async setExternalServer(
+    serverType: 'smartexpress',
+    serverArg: pluginsTyped.smartexpress.Server
+  ) {
+    this.httpServerDeferred = plugins.smartpromise.defer();
+    await serverArg.startedPromise;
+    this.httpServer = serverArg.httpServer;
+    this.httpServerDeferred.resolve();
+  }
+
+  /**
+   * gets the server for socket.io
+   */
+  public async getServerForSocketIo() {
+    if (this.httpServerDeferred) {
+      await this.httpServerDeferred.promise;
+    }
+    if (this.httpServer) {
+      return this.httpServer;
+    } else {
+      const httpModule = await this.smartsocket.smartenv.getSafeNodeModule('http');
+      this.httpServer = new httpModule.Server();
+      this.standaloneServer = true;
+      return this.httpServer;
+    }
+  }
+
+  /**
+   * starts listening to incoming sockets:
+   */
+  public async start() {
+    const done = plugins.smartpromise.defer();
+
+    // handle http servers
+    // in case an external server has been set "this.standaloneServer" should be false
+    if (this.httpServer && this.standaloneServer) {
+      if (!this.smartsocket.options.port) {
+        logger.log('error', 'there should be a port specifed for smartsocket!');
+        throw new Error('there should be a port specified for smartsocket');
+      }
+      this.httpServer.listen(this.smartsocket.options.port, () => {
+        logger.log(
+          'success',
+          `Server started in standalone mode on ${this.smartsocket.options.port}`
+        );
+        done.resolve();
+      });
+    } else {
+      done.resolve();
+    }
+
+    // nothing else to do if express server is set
+    await done.promise;
+    return;
+  }
+
+  /**
+   * closes the server
+   */
+  public async stop() {
+    if (this.httpServer) {
+      this.httpServer.close();
+    }
+  }
+}

package/ts/smartsocket.logging.ts

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

package/ts/smartsocket.plugins.ts

@@ -0,0 +1,29 @@
+// apiglobal scope
+import * as typedrequestInterfaces from '@apiglobal/typedrequest-interfaces';
+
+export { typedrequestInterfaces };
+
+// pushrocks scope
+import * as isohash from '@pushrocks/isohash';
+import * as isounique from '@pushrocks/isounique';
+import * as lik from '@pushrocks/lik';
+import * as smartenv from '@pushrocks/smartenv';
+import * as smartjson from '@pushrocks/smartjson';
+import * as smartlog from '@pushrocks/smartlog';
+import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smarttime from '@pushrocks/smarttime';
+import * as smartrx from '@pushrocks/smartrx';
+
+export {
+  isohash,
+  isounique,
+  lik,
+  smartenv,
+  smartjson,
+  smartlog,
+  smartdelay,
+  smartpromise,
+  smarttime,
+  smartrx,
+};

package/ts/smartsocket.pluginstyped.ts

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