@clairejs/server 3.15.2 → 3.16.0

package/dist/socket/AbstractServerSocketManager.js

@@ -0,0 +1,348 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { AccessConditionValueType, DataType, Errors, getObjectMetadata, getServiceProvider, MessageType, Register, SocketMethod, } from "@clairejs/core";
+import { AbstractAccessCondition } from "../http/security/AbstractAccessCondition";
+import { HttpRequest } from "../http/common/HttpRequest";
+import { AbstractSocketConnectionHandler } from "./AbstractSocketConnectionHandler";
+import { AbstractSocketController } from "./AbstractSocketController";
+const SOCKET_ACTION_HEADER = "x-socket-action";
+const SOCKET_ACTION_READ = "read";
+const SOCKET_ACTION_WRITE = "write";
+let SocketReadCondition = class SocketReadCondition extends AbstractAccessCondition {
+    async resolveConditionValue(request) {
+        return request.headers[SOCKET_ACTION_HEADER] === SOCKET_ACTION_READ;
+    }
+    async validate(conditionValue) {
+        return !!conditionValue;
+    }
+    getConditionMetadata() {
+        return {
+            name: "disable_write",
+            description: "Disable send message to channel",
+            valueType: AccessConditionValueType.BOOLEAN,
+        };
+    }
+};
+SocketReadCondition = __decorate([
+    Register()
+], SocketReadCondition);
+let SocketWriteCondition = class SocketWriteCondition extends AbstractAccessCondition {
+    async resolveConditionValue(request) {
+        return request.headers[SOCKET_ACTION_HEADER] === SOCKET_ACTION_WRITE;
+    }
+    async validate(conditionValue) {
+        return !!conditionValue;
+    }
+    getConditionMetadata() {
+        return {
+            name: "disable_read",
+            description: "Disable receive message from channel",
+            valueType: AccessConditionValueType.BOOLEAN,
+        };
+    }
+};
+SocketWriteCondition = __decorate([
+    Register()
+], SocketWriteCondition);
+export class AbstractServerSocketManager {
+    requireAuthentication;
+    logger;
+    redisClient;
+    principalResolver;
+    requestAuthorizer;
+    mountedEndpointInfo;
+    _connectionHandler = null;
+    constructor(requireAuthentication, logger, redisClient, principalResolver, requestAuthorizer) {
+        this.requireAuthentication = requireAuthentication;
+        this.logger = logger;
+        this.redisClient = redisClient;
+        this.principalResolver = principalResolver;
+        this.requestAuthorizer = requestAuthorizer;
+    }
+    getUniqueChannelPrefix() {
+        return `CHANNEL:`;
+    }
+    getSocketInfoHashKey() {
+        return `__SOCKET_INFO__`;
+    }
+    async getConnectionHandler() {
+        if (this._connectionHandler === null) {
+            const injector = getServiceProvider().getInjector();
+            this._connectionHandler = injector.resolveOptional(AbstractSocketConnectionHandler);
+            await injector.initInstances();
+        }
+        return this._connectionHandler;
+    }
+    formatBroadcastData(channel, data) {
+        const rawData = {
+            type: MessageType.PLAIN,
+            data: { channel, message: data },
+        };
+        return rawData;
+    }
+    getUniqueChannelName(channel) {
+        return `${this.getUniqueChannelPrefix()}${channel}`;
+    }
+    async getSocketIdsOfChannel(channel) {
+        const socketIds = await this.redisClient.smembers(this.getUniqueChannelName(channel));
+        return socketIds || [];
+    }
+    async addSocketToChannel(socketId, channelInfos) {
+        const socket = await this.getById(socketId);
+        if (socket) {
+            socket.addChannels(channelInfos);
+            await Promise.all(channelInfos.map((channelInfo) => this.redisClient.sadd(this.getUniqueChannelName(channelInfo.name), socketId)));
+            await socket.saveSocketInfo();
+        }
+        return socket;
+    }
+    async removeSocketFromChannel(socketId, channels, persist = true) {
+        if (!channels.length) {
+            return;
+        }
+        const socket = await this.getById(socketId);
+        if (socket) {
+            socket.removeChannels(channels);
+            await Promise.all(channels.map((channel) => this.redisClient.srem(this.getUniqueChannelName(channel), socketId)));
+            if (persist) {
+                await socket.saveSocketInfo();
+            }
+        }
+    }
+    async removeSocket(socketId, _physicRemove = true) {
+        const socket = await this.getById(socketId);
+        if (socket) {
+            this.logger.debug("Remove from all channels");
+            await this.removeSocketFromChannel(socketId, socket.getChannelsInfo().map((c) => c.name), false);
+        }
+        //-- remove from redis
+        this.logger.debug("Remove from redis");
+        await this.redisClient.hdel(this.getSocketInfoHashKey(), socketId);
+    }
+    async handle(socketData) {
+        this.logger.debug("Handle socket data", socketData);
+        //-- check and handle socket creation
+        const connectionHandler = await this.getConnectionHandler();
+        switch (socketData.method) {
+            case SocketMethod.CONNECT: {
+                this.logger.debug("Socket connection attempt", socketData);
+                //-- try resolve principal
+                const socketRequest = new HttpRequest({
+                    method: SocketMethod.CONNECT,
+                    query: socketData.data.queries,
+                    pathName: "",
+                });
+                const principal = await this.principalResolver.resolvePrincipal(socketRequest);
+                if (!principal && this.requireAuthentication) {
+                    throw Errors.ACCESS_DENIED("Authentication required");
+                }
+                //-- generate server socket
+                await this.addSocket({
+                    id: socketData.socketId,
+                    authInfo: principal,
+                    channels: [],
+                    createdAt: Date.now(),
+                }, socketData.data);
+                break;
+            }
+            case SocketMethod.DISCONNECT: {
+                this.logger.debug("Socket disconnect", socketData);
+                const socket = await this.getById(socketData.socketId);
+                if (socket) {
+                    const mountedEndpoints = await this.getMountedEndpointInfo();
+                    //-- notify all channels
+                    this.logger.debug("Notify channels");
+                    for (const channelInfo of socket.getChannelsInfo()) {
+                        const currentEndpoint = mountedEndpoints.find((e) => e.endpointMetadata.url === channelInfo.name);
+                        if (currentEndpoint) {
+                            currentEndpoint.endpoint.controller.onChannelLeave(socket);
+                        }
+                    }
+                    this.logger.debug("Calling disconnection handler");
+                    connectionHandler?.onSocketDisconnect(socket);
+                    this.logger.debug("Removing socket");
+                    await this.removeSocket(socket.getId(), false);
+                }
+                break;
+            }
+            case SocketMethod.MESSAGE: {
+                this.logger.debug("Socket message", socketData);
+                const message = socketData.data;
+                let clientSocket = await this.getById(socketData.socketId);
+                if (!clientSocket) {
+                    this.logger.debug("Socket not found", socketData.socketId);
+                }
+                else {
+                    switch (message.type) {
+                        case MessageType.READY:
+                            //-- client socket ready
+                            await clientSocket.sendRaw({
+                                type: MessageType.READY,
+                                data: "",
+                            });
+                            //-- call connection handler
+                            await connectionHandler?.onSocketConnect(clientSocket);
+                            break;
+                        case MessageType.PING_PONG:
+                            {
+                                //-- send back pong
+                                await clientSocket.sendRaw({
+                                    type: MessageType.PING_PONG,
+                                    data: message.data,
+                                });
+                            }
+                            break;
+                        case MessageType.CHANNEL_JOIN:
+                            {
+                                //-- check channels join permission
+                                const channels = message.data;
+                                const channelsInfo = [];
+                                const endpoints = [];
+                                for (const channel of channels) {
+                                    let canSend = false;
+                                    let canReceived = false;
+                                    const mountedEndpoints = await this.getMountedEndpointInfo();
+                                    const currentEndpoint = mountedEndpoints.find((e) => e.endpointMetadata.url === channel);
+                                    if (!currentEndpoint) {
+                                        continue;
+                                    }
+                                    try {
+                                        const request = new HttpRequest({
+                                            method: SocketMethod.MESSAGE,
+                                            pathName: channel,
+                                            headers: { [SOCKET_ACTION_HEADER]: SOCKET_ACTION_READ },
+                                        }, currentEndpoint.endpointMetadata);
+                                        await this.requestAuthorizer.authorize(request, currentEndpoint);
+                                        canReceived = true;
+                                    }
+                                    catch (err) {
+                                        this.logger.debug("Error in read authorize", err);
+                                    }
+                                    try {
+                                        const request = new HttpRequest({
+                                            method: SocketMethod.MESSAGE,
+                                            pathName: channel,
+                                            headers: { [SOCKET_ACTION_HEADER]: SOCKET_ACTION_WRITE },
+                                        }, currentEndpoint.endpointMetadata);
+                                        await this.requestAuthorizer.authorize(request, currentEndpoint);
+                                        canSend = true;
+                                    }
+                                    catch (err) {
+                                        this.logger.debug("Error in write authorize", err);
+                                    }
+                                    if (canSend || canReceived) {
+                                        this.logger.debug("Adding channel info", channel, canSend, canReceived);
+                                        channelsInfo.push({
+                                            name: channel,
+                                            clientToServerAllowed: canSend,
+                                            serverToClientAllowed: canReceived,
+                                        });
+                                        endpoints.push(currentEndpoint);
+                                    }
+                                }
+                                //-- join socket to channels
+                                clientSocket = await this.addSocketToChannel(clientSocket.getId(), channelsInfo);
+                                if (!clientSocket) {
+                                    this.logger.debug("Socket not found after addSocketToChannel");
+                                }
+                                else {
+                                    //-- send back
+                                    await Promise.all([
+                                        clientSocket.sendRaw({
+                                            type: MessageType.CHANNEL_JOIN,
+                                            data: channelsInfo.map((c) => c.name),
+                                        }),
+                                        ...endpoints.map((endpoint) => endpoint.endpoint.controller.onChannelJoin(clientSocket)),
+                                    ]);
+                                }
+                            }
+                            break;
+                        case MessageType.CHANNEL_LEAVE:
+                            {
+                                const channels = message.data;
+                                //-- remove channels from socket
+                                const mountedEndpoints = await this.getMountedEndpointInfo();
+                                Promise.all(channels.map((channel) => () => {
+                                    const currentEndpoint = mountedEndpoints.find((e) => e.endpointMetadata.url === channel);
+                                    if (!currentEndpoint) {
+                                        return;
+                                    }
+                                    return currentEndpoint.endpoint.controller.onChannelLeave(clientSocket);
+                                }));
+                                //-- remove socket from channels
+                                await this.removeSocketFromChannel(clientSocket.getId(), channels);
+                            }
+                            break;
+                        case MessageType.PLAIN:
+                            {
+                                const channel = message.data.channel;
+                                const data = message.data.message;
+                                //-- check if socket is allowed to send
+                                if (channel) {
+                                    //-- check if socket is allowed to send to channel
+                                    const allowed = clientSocket
+                                        .getChannelsInfo()
+                                        .find((info) => info.name === channel && info.clientToServerAllowed);
+                                    if (allowed) {
+                                        const mountedEndpoints = await this.getMountedEndpointInfo();
+                                        const currentEndpoint = mountedEndpoints.find((e) => e.endpointMetadata.url === channel);
+                                        if (currentEndpoint) {
+                                            const result = await currentEndpoint.endpoint.controller.onMessage(clientSocket, data);
+                                            if (result !== false) {
+                                                //-- broadcast
+                                                this.logger.debug("broadcasting to channel", channel, data);
+                                                this.broadcastToChannel(channel, data);
+                                            }
+                                        }
+                                    }
+                                }
+                                else {
+                                    await connectionHandler?.onMessage(clientSocket, data);
+                                }
+                            }
+                            break;
+                        default:
+                            //-- invalid message format ignore
+                            this.logger.debug("Invalid message format", message);
+                            break;
+                    }
+                }
+                break;
+            }
+            default:
+                return undefined;
+        }
+    }
+    async getMountedEndpointInfo() {
+        if (!this.mountedEndpointInfo) {
+            const injector = getServiceProvider().getInjector();
+            const socketController = injector.resolveMultiple(AbstractSocketController);
+            await injector.initInstances();
+            this.mountedEndpointInfo = socketController.map((controller) => {
+                const controllerMetadata = getObjectMetadata(controller.constructor);
+                return {
+                    endpoint: {
+                        httpMethod: SocketMethod.MESSAGE,
+                        mount: controller.getChannelName(),
+                        controller: controller,
+                        handlerFunctionName: controller.onMessage.name,
+                    },
+                    endpointMetadata: {
+                        httpMethod: SocketMethod.MESSAGE,
+                        description: "Send / Receive message to / from channel",
+                        permissionGroup: controllerMetadata.permissionGroup,
+                        dataType: DataType.OBJECT,
+                        url: controller.getChannelName(),
+                        name: controller.getChannelName(),
+                        accessConditions: [SocketReadCondition, SocketWriteCondition],
+                    },
+                };
+            });
+        }
+        return this.mountedEndpointInfo;
+    }
+}

package/dist/socket/AbstractSocketConnectionHandler.js

@@ -0,0 +1,2 @@
+export class AbstractSocketConnectionHandler {
+}

package/dist/socket/AbstractSocketController.d.ts

@@ -2,13 +2,13 @@ import { AbstractController } from "../common/AbstractController";
 import { IServerSocket } from "./IServerSocket";
 export declare abstract class AbstractSocketController extends AbstractController {
     abstract getChannelName(): string;
-    onChannelJoin(socket: IServerSocket): Promise<void>;
-    onChannelLeave(socket: IServerSocket): Promise<void>;
+    onChannelJoin(_socket: IServerSocket): Promise<void>;
+    onChannelLeave(_socket: IServerSocket): Promise<void>;
     /**
      * Handle the message sent to this channel
      * @param socket the socket sending message
      * @param data the data payload being sent
      * @returns return false to prevent message broadcast
      */
-    onMessage(socket: IServerSocket, message: any): Promise<boolean | void>;
+    onMessage(_socket: IServerSocket, _message: any): Promise<boolean | void>;
 }

package/dist/socket/AbstractSocketController.js

@@ -0,0 +1,12 @@
+import { AbstractController } from "../common/AbstractController";
+export class AbstractSocketController extends AbstractController {
+    async onChannelJoin(_socket) { }
+    async onChannelLeave(_socket) { }
+    /**
+     * Handle the message sent to this channel
+     * @param socket the socket sending message
+     * @param data the data payload being sent
+     * @returns return false to prevent message broadcast
+     */
+    async onMessage(_socket, _message) { }
+}

package/dist/socket/AwsSocketManager.d.ts

@@ -21,10 +21,10 @@ export declare class AwsSocketManager extends AbstractServerSocketManager implem
     exit(): void;
     removeSocketFromRedis(socketId: string): Promise<void>;
     physicSend(socketId: string, data: any): Promise<void>;
-    configure(data?: any): void;
+    configure(_data?: any): void;
     getSocketsByChannel(channel: string): Promise<IServerSocket[]>;
     broadcastToChannel(channel: string, data: any): Promise<void>;
-    addSocket(socketInfo: ServerSocketInfo, data: any): Promise<AbstractServerSocket>;
+    addSocket(socketInfo: ServerSocketInfo, _data: any): Promise<AbstractServerSocket>;
     removeSocket(socketId: string, physicRemove?: boolean): Promise<void>;
     private getSocketBySerialized;
     getById(socketId: string): Promise<AbstractServerSocket | undefined>;

package/dist/socket/AwsSocketManager.js

@@ -0,0 +1,160 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { AbstractLogger, Initable, LogContext } from "@clairejs/core";
+import aws from "aws-sdk";
+import Redis from "ioredis";
+import { AbstractHttpRequestHandler } from "../http/controller/AbstractHttpRequestHandler";
+import { AbstractServerSocketManager } from "./AbstractServerSocketManager";
+import { AbstractServerSocket } from "./AbstractServerSocket";
+import { AbstractRequestAuthorizer } from "../http/auth/AbstractHttpAuthorizer";
+import { AbstractPrincipalResolver } from "../common/auth/AbstractPrincipalResolver";
+class ApiGatewaySocket extends AbstractServerSocket {
+    socketManager;
+    socketInfo;
+    apiGateway;
+    socketNamespace;
+    redisClient;
+    constructor(socketManager, socketInfo, apiGateway, socketNamespace, redisClient) {
+        super(socketInfo);
+        this.socketManager = socketManager;
+        this.socketInfo = socketInfo;
+        this.apiGateway = apiGateway;
+        this.socketNamespace = socketNamespace;
+        this.redisClient = redisClient;
+    }
+    async saveSocketInfo() {
+        await this.redisClient.hset(this.socketNamespace, this.socketInfo.id, JSON.stringify(this.socketInfo));
+    }
+    async physicSend(data) {
+        await this.socketManager.physicSend(this.getId(), data);
+    }
+    async disconnect(err) {
+        if (err) {
+            await this.physicSend(err);
+        }
+        await this.socketManager.removeSocket(this.getId());
+    }
+    serialize() {
+        return JSON.stringify(this.socketInfo);
+    }
+}
+let AwsSocketManager = class AwsSocketManager extends AbstractServerSocketManager {
+    authenticationRequired;
+    region;
+    socketDomainUrl;
+    redis;
+    httpRequestHandler;
+    principalResolver;
+    requestAuthorizer;
+    logger;
+    apiGatewayManagement;
+    constructor(authenticationRequired, region, socketDomainUrl, redis, httpRequestHandler, principalResolver, requestAuthorizer, logger) {
+        super(authenticationRequired, logger, redis, principalResolver, requestAuthorizer);
+        this.authenticationRequired = authenticationRequired;
+        this.region = region;
+        this.socketDomainUrl = socketDomainUrl;
+        this.redis = redis;
+        this.httpRequestHandler = httpRequestHandler;
+        this.principalResolver = principalResolver;
+        this.requestAuthorizer = requestAuthorizer;
+        this.logger = logger;
+        this.apiGatewayManagement = new aws.ApiGatewayManagementApi({
+            region,
+            apiVersion: "2018-11-29",
+            endpoint: socketDomainUrl,
+        });
+    }
+    async init() {
+        this.logger.info("AwsSocketManager init");
+    }
+    exit() {
+        this.redisClient.disconnect();
+        this.logger.info("AwsSocketManager exit");
+    }
+    async removeSocketFromRedis(socketId) {
+        await this.redisClient.hdel(this.getSocketInfoHashKey(), socketId);
+    }
+    async physicSend(socketId, data) {
+        try {
+            this.logger.debug(`Socket ${socketId} sending`, data);
+            await this.apiGatewayManagement
+                .postToConnection({ ConnectionId: socketId, Data: JSON.stringify(data) })
+                .promise();
+        }
+        catch (err) {
+            this.logger.debug(`Socket ${socketId} post error`, err);
+            //-- socket is gone
+            if (err.statusCode === 410) {
+                //-- can not send, remove staled socket
+                this.logger.debug(`Disconnect & remove stale socket ${socketId}`);
+                await this.removeSocket(socketId, false);
+                this.logger.debug(`Socket removed ${socketId}`);
+            }
+            throw err;
+        }
+    }
+    configure(_data) {
+        this.logger.debug("Aws socket manager configure");
+    }
+    async getSocketsByChannel(channel) {
+        const socketIds = await this.getSocketIdsOfChannel(channel);
+        if (!socketIds.length) {
+            return [];
+        }
+        const data = await this.redisClient.hmget(this.getSocketInfoHashKey(), ...socketIds);
+        return data.filter((serialized) => !!serialized).map((s) => this.getSocketBySerialized(s));
+    }
+    async broadcastToChannel(channel, data) {
+        //-- get all channels
+        const socketIds = await this.getSocketIdsOfChannel(channel);
+        if (socketIds.length) {
+            const formattedData = this.formatBroadcastData(channel, data);
+            socketIds.map((socketId) => this.physicSend(socketId, formattedData).catch((err) => this.logger.error(`Cannot send to socket ${socketId}`, err)));
+        }
+    }
+    async addSocket(socketInfo, _data) {
+        const socket = new ApiGatewaySocket(this, socketInfo, this.apiGatewayManagement, this.getSocketInfoHashKey(), this.redisClient);
+        await socket.saveSocketInfo();
+        return socket;
+    }
+    async removeSocket(socketId, physicRemove = true) {
+        this.logger.debug(`Aws socket manager remove socket: ${socketId}, ${physicRemove}`);
+        await super.removeSocket(socketId, physicRemove);
+        this.logger.debug("Super remove ok");
+        if (physicRemove) {
+            this.apiGatewayManagement
+                .deleteConnection({ ConnectionId: socketId })
+                .promise()
+                .catch((err) => this.logger.error("Cannot physic remove aws socket", err));
+        }
+    }
+    getSocketBySerialized(serialized) {
+        return new ApiGatewaySocket(this, JSON.parse(serialized), this.apiGatewayManagement, this.getSocketInfoHashKey(), this.redisClient);
+    }
+    async getById(socketId) {
+        const serialized = await this.redisClient.hget(this.getSocketInfoHashKey(), socketId);
+        if (!serialized) {
+            this.logger.error("Cannot find socket with id: " + socketId);
+            return undefined;
+        }
+        this.logger.debug("Serialized aws socket", serialized);
+        return this.getSocketBySerialized(serialized);
+    }
+};
+AwsSocketManager = __decorate([
+    Initable(),
+    LogContext(),
+    __metadata("design:paramtypes", [Boolean, String, String, Redis,
+        AbstractHttpRequestHandler,
+        AbstractPrincipalResolver,
+        AbstractRequestAuthorizer,
+        AbstractLogger])
+], AwsSocketManager);
+export { AwsSocketManager };

package/dist/socket/IServerSocket.js

@@ -0,0 +1 @@
+export {};