@push.rocks/smartsocket 2.0.19

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@pushrocks/smartsocket',
+    version: '2.0.19',
+    description: 'easy and secure websocket communication'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHlDQUF5QztDQUN2RCxDQUFBIn0=

package/dist_ts/index.d.ts

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

package/dist_ts/index.js

@@ -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';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxzQkFBc0I7QUFDdEIsY0FBYyxzQ0FBc0MsQ0FBQztBQUNyRCxjQUFjLDRDQUE0QyxDQUFDO0FBRTNELHFDQUFxQztBQUNyQyxjQUFjLHlDQUF5QyxDQUFDO0FBQ3hELGNBQWMsMkNBQTJDLENBQUMifQ==

package/dist_ts/interfaces/connection.d.ts

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

package/dist_ts/interfaces/connection.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL2ludGVyZmFjZXMvY29ubmVjdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist_ts/interfaces/index.d.ts

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

package/dist_ts/interfaces/index.js

@@ -0,0 +1,3 @@
+export * from './connection.js';
+export * from './tag.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbnRlcmZhY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxVQUFVLENBQUMifQ==

package/dist_ts/interfaces/tag.d.ts

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

package/dist_ts/interfaces/tag.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvaW50ZXJmYWNlcy90YWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist_ts/smartsocket.classes.smartsocket.d.ts

@@ -0,0 +1,43 @@
+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 { SocketFunction } from './smartsocket.classes.socketfunction.js';
+import { SocketRequest } from './smartsocket.classes.socketrequest.js';
+export interface ISmartsocketConstructorOptions {
+    alias: string;
+    port?: number;
+}
+export declare class Smartsocket {
+    /**
+     * a unique id to detect server restarts
+     */
+    alias: string;
+    smartenv: plugins.smartenv.Smartenv;
+    options: ISmartsocketConstructorOptions;
+    io: pluginsTyped.socketIo.Server;
+    socketConnections: plugins.lik.ObjectMap<SocketConnection>;
+    socketFunctions: plugins.lik.ObjectMap<SocketFunction<any>>;
+    socketRequests: plugins.lik.ObjectMap<SocketRequest<any>>;
+    eventSubject: plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>;
+    private socketServer;
+    constructor(optionsArg: ISmartsocketConstructorOptions);
+    setExternalServer(serverType: 'smartexpress', serverArg: any): Promise<void>;
+    /**
+     * starts smartsocket
+     */
+    start(): Promise<void>;
+    /**
+     * stops smartsocket
+     */
+    stop(): Promise<void>;
+    /**
+     * allows call to specific client.
+     */
+    clientCall<T extends plugins.typedrequestInterfaces.ITypedRequest>(functionNameArg: T['method'], dataArg: T['request'], targetSocketConnectionArg: SocketConnection): Promise<T['response']>;
+    addSocketFunction(socketFunction: SocketFunction<any>): void;
+    /**
+     * the standard handler for new socket connections
+     */
+    private _handleSocketConnection;
+}

package/dist_ts/smartsocket.classes.smartsocket.js

@@ -0,0 +1,102 @@
+import * as plugins from './smartsocket.plugins.js';
+import './smartsocket.pluginstyped.js';
+import './interfaces/index.js';
+// classes
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
+import './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 class Smartsocket {
+    constructor(optionsArg) {
+        this.smartenv = new plugins.smartenv.Smartenv();
+        this.socketConnections = new plugins.lik.ObjectMap();
+        this.socketFunctions = new plugins.lik.ObjectMap();
+        this.socketRequests = new plugins.lik.ObjectMap();
+        this.eventSubject = new plugins.smartrx.rxjs.Subject();
+        this.socketServer = new SocketServer(this);
+        this.options = optionsArg;
+        this.alias = plugins.isounique.uni(this.options.alias);
+    }
+    async setExternalServer(serverType, serverArg) {
+        await this.socketServer.setExternalServer(serverType, serverArg);
+    }
+    /**
+     * starts smartsocket
+     */
+    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
+     */
+    async stop() {
+        await plugins.smartdelay.delayFor(1000);
+        this.socketConnections.forEach((socketObjectArg) => {
+            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.
+     */
+    async clientCall(functionNameArg, dataArg, targetSocketConnectionArg) {
+        const socketRequest = new SocketRequest(this, {
+            funcCallData: {
+                funcDataArg: dataArg,
+                funcName: functionNameArg,
+            },
+            originSocketConnection: targetSocketConnectionArg,
+            shortId: plugins.isounique.uni(),
+            side: 'requesting',
+        });
+        const response = await socketRequest.dispatch();
+        const result = response.funcDataArg;
+        return result;
+    }
+    addSocketFunction(socketFunction) {
+        this.socketFunctions.add(socketFunction);
+    }
+    /**
+     * the standard handler for new socket connections
+     */
+    async _handleSocketConnection(socketArg) {
+        const 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');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartsocket.classes.smartsocketclient.d.ts

@@ -0,0 +1,64 @@
+import * as plugins from './smartsocket.plugins.js';
+import * as interfaces from './interfaces/index.js';
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
+import { SocketFunction } from './smartsocket.classes.socketfunction.js';
+import { SocketRequest } from './smartsocket.classes.socketrequest.js';
+/**
+ * interface for class SmartsocketClient
+ */
+export interface ISmartsocketClientOptions {
+    port: number;
+    url: string;
+    alias: string;
+    autoReconnect?: boolean;
+}
+export declare class SmartsocketClient {
+    shortId: string;
+    remoteShortId: string;
+    alias: string;
+    socketConnection: SocketConnection;
+    serverUrl: string;
+    serverPort: number;
+    autoReconnect: boolean;
+    eventSubject: plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>;
+    eventStatus: interfaces.TConnectionStatus;
+    socketFunctions: plugins.lik.ObjectMap<SocketFunction<any>>;
+    socketRequests: plugins.lik.ObjectMap<SocketRequest<any>>;
+    private tagStore;
+    private tagStoreSubscription;
+    /**
+     * adds a tag to a connection
+     */
+    addTag(tagArg: interfaces.ITag): Promise<void>;
+    /**
+     * gets a tag by id
+     * @param tagIdArg
+     */
+    getTagById(tagIdArg: interfaces.ITag['id']): Promise<interfaces.ITag<any>>;
+    /**
+     * removes a tag from a connection
+     */
+    removeTagById(tagIdArg: interfaces.ITag['id']): Promise<void>;
+    constructor(optionsArg: ISmartsocketClientOptions);
+    addSocketFunction(socketFunction: SocketFunction<any>): void;
+    /**
+     * connect the client to the server
+     */
+    connect(): Promise<unknown>;
+    private disconnectRunning;
+    /**
+     * disconnect from the server
+     */
+    disconnect(useAutoReconnectSetting?: boolean): Promise<void>;
+    /**
+     * stops the client completely
+     */
+    stop(): Promise<void>;
+    /**
+     * dispatches a server call
+     * @param functionNameArg
+     * @param dataArg
+     */
+    serverCall<T extends plugins.typedrequestInterfaces.ITypedRequest>(functionNameArg: T['method'], dataArg: T['request']): Promise<T['response']>;
+    private updateStatus;
+}

package/dist_ts/smartsocket.classes.smartsocketclient.js

@@ -0,0 +1,217 @@
+import * as plugins from './smartsocket.plugins.js';
+import './smartsocket.pluginstyped.js';
+import './interfaces/index.js';
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
+import './smartsocket.classes.socketfunction.js';
+import { SocketRequest } from './smartsocket.classes.socketrequest.js';
+import { logger } from './smartsocket.logging.js';
+export class SmartsocketClient {
+    /**
+     * adds a tag to a connection
+     */
+    async addTag(tagArg) {
+        if (this.socketConnection) {
+            await this.socketConnection.addTag(tagArg);
+        }
+        else {
+            this.tagStore[tagArg.id] = tagArg;
+        }
+    }
+    /**
+     * gets a tag by id
+     * @param tagIdArg
+     */
+    async getTagById(tagIdArg) {
+        return this.tagStore[tagIdArg];
+    }
+    /**
+     * removes a tag from a connection
+     */
+    async removeTagById(tagIdArg) {
+        if (this.socketConnection) {
+            this.socketConnection.removeTagById(tagIdArg);
+        }
+        else {
+            delete this.tagStore[tagIdArg];
+        }
+    }
+    constructor(optionsArg) {
+        // a unique id
+        this.shortId = plugins.isounique.uni();
+        // the shortId of the remote we connect to
+        this.remoteShortId = null;
+        // status handling
+        this.eventSubject = new plugins.smartrx.rxjs.Subject();
+        this.eventStatus = 'new';
+        this.socketFunctions = new plugins.lik.ObjectMap();
+        this.socketRequests = new plugins.lik.ObjectMap();
+        // tagStore
+        this.tagStore = {};
+        this.disconnectRunning = false;
+        this.alias = optionsArg.alias;
+        this.serverUrl = optionsArg.url;
+        this.serverPort = optionsArg.port;
+        this.autoReconnect = optionsArg.autoReconnect;
+    }
+    addSocketFunction(socketFunction) {
+        this.socketFunctions.add(socketFunction);
+    }
+    /**
+     * connect the client to the server
+     */
+    async connect() {
+        const done = plugins.smartpromise.defer();
+        const smartenvInstance = new plugins.smartenv.Smartenv();
+        const socketIoClient = 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.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) => {
+            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;
+    }
+    /**
+     * disconnect from the server
+     */
+    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
+     */
+    async stop() {
+        this.autoReconnect = false;
+        await this.disconnect();
+    }
+    /**
+     * dispatches a server call
+     * @param functionNameArg
+     * @param dataArg
+     */
+    async serverCall(functionNameArg, dataArg) {
+        const done = plugins.smartpromise.defer();
+        const socketRequest = new SocketRequest(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;
+    }
+    updateStatus(statusArg) {
+        if (this.eventStatus !== statusArg) {
+            this.eventSubject.next(statusArg);
+        }
+        this.eventStatus = statusArg;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartsocket.classes.smartsocketclient.js","sourceRoot":"","sources":["../ts/smartsocket.classes.smartsocketclient.ts"],"names":[],"mappings":"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"}

package/dist_ts/smartsocket.classes.socketconnection.d.ts

@@ -0,0 +1,65 @@
+import * as plugins from './smartsocket.plugins.js';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';
+import * as interfaces from './interfaces/index.js';
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient.js';
+/**
+ * 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 declare let allSocketConnections: plugins.lik.ObjectMap<SocketConnection>;
+/**
+ * class SocketConnection represents a websocket connection
+ */
+export declare class SocketConnection {
+    alias: string;
+    side: TSocketConnectionSide;
+    authenticated: boolean;
+    smartsocketRef: Smartsocket | SmartsocketClient;
+    socket: pluginsTyped.socketIo.Socket | pluginsTyped.socketIoClient.Socket;
+    eventSubject: plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>;
+    eventStatus: interfaces.TConnectionStatus;
+    private tagStore;
+    tagStoreObservable: plugins.smartrx.rxjs.Subject<interfaces.TTagStore>;
+    remoteTagStoreObservable: plugins.smartrx.rxjs.Subject<interfaces.TTagStore>;
+    constructor(optionsArg: ISocketConnectionConstructorOptions);
+    /**
+     * adds a tag to a connection
+     */
+    addTag(tagArg: interfaces.ITag): Promise<void>;
+    /**
+     * gets a tag by id
+     * @param tagIdArg
+     */
+    getTagById(tagIdArg: interfaces.ITag['id']): Promise<interfaces.ITag<any>>;
+    /**
+     * removes a tag from a connection
+     */
+    removeTagById(tagIdArg: interfaces.ITag['id']): Promise<void>;
+    /**
+     * authenticate the socket
+     */
+    authenticate(): Promise<unknown>;
+    /**
+     * listen to function requests
+     */
+    listenToFunctionRequests(): Promise<unknown>;
+    disconnect(): Promise<void>;
+    private updateStatus;
+}