@clairejs/server 3.15.2 → 3.16.0

package/dist/socket/LocalSocketManager.js

@@ -0,0 +1,292 @@
+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, MessageType, SocketMethod } from "@clairejs/core";
+import WebSocket from "ws";
+import parseurl from "parseurl";
+import queryString from "query-string";
+import Redis from "ioredis";
+import { AbstractServerSocketManager } from "./AbstractServerSocketManager";
+import { AbstractServerSocket } from "./AbstractServerSocket";
+import { AbstractRequestAuthorizer } from "../http/auth/AbstractHttpAuthorizer";
+import { AbstractPrincipalResolver } from "../common/auth/AbstractPrincipalResolver";
+var RedisSocketCommand;
+(function (RedisSocketCommand) {
+    RedisSocketCommand["SEND"] = "SEND";
+    RedisSocketCommand["CLOSE"] = "CLOSE";
+    RedisSocketCommand["SAVE"] = "SAVE";
+})(RedisSocketCommand || (RedisSocketCommand = {}));
+class RedisSocket extends AbstractServerSocket {
+    socketChannelName;
+    redisClient;
+    socketInfo;
+    constructor(socketChannelName, redisClient, socketInfo) {
+        super(socketInfo);
+        this.socketChannelName = socketChannelName;
+        this.redisClient = redisClient;
+        this.socketInfo = socketInfo;
+    }
+    async physicSend(data) {
+        await this.redisClient.publish(this.socketChannelName, JSON.stringify({
+            type: RedisSocketCommand.SEND,
+            data: data,
+        }));
+    }
+    async disconnect(err) {
+        await this.redisClient.publish(this.socketChannelName, JSON.stringify({
+            type: RedisSocketCommand.CLOSE,
+            data: err,
+        }));
+    }
+    async saveSocketInfo() {
+        await this.redisClient.publish(this.socketChannelName, JSON.stringify({
+            type: RedisSocketCommand.SAVE,
+            data: this.socketInfo,
+        }));
+    }
+}
+class ExpressSocket extends AbstractServerSocket {
+    socketManager;
+    socket;
+    socketInfo;
+    infoSaver;
+    constructor(socketManager, socket, socketInfo, infoSaver) {
+        super(socketInfo);
+        this.socketManager = socketManager;
+        this.socket = socket;
+        this.socketInfo = socketInfo;
+        this.infoSaver = infoSaver;
+    }
+    async saveSocketInfo() {
+        //-- save to redis
+        await this.infoSaver(this.socketInfo);
+    }
+    async physicSend(data) {
+        this.socket.send(JSON.stringify(data));
+    }
+    async disconnect(err) {
+        this.socket.close(1000, err && JSON.stringify(err));
+        await this.socketManager.removeSocket(this.getId());
+    }
+}
+let LocalSocketManager = class LocalSocketManager extends AbstractServerSocketManager {
+    authenticationRequired;
+    subClient;
+    channelSubClient;
+    sendClient;
+    logger;
+    principalResolver;
+    requestAuthorizer;
+    allSockets = [];
+    subscribedChannels = [];
+    constructor(authenticationRequired, subClient, //-- use to subscribe to the socket-self channels
+    channelSubClient, //-- use to subscribe to channels
+    sendClient, //-- use to publish data
+    logger, principalResolver, requestAuthorizer) {
+        super(authenticationRequired, logger, sendClient, principalResolver, requestAuthorizer);
+        this.authenticationRequired = authenticationRequired;
+        this.subClient = subClient;
+        this.channelSubClient = channelSubClient;
+        this.sendClient = sendClient;
+        this.logger = logger;
+        this.principalResolver = principalResolver;
+        this.requestAuthorizer = requestAuthorizer;
+    }
+    async init() {
+        this.logger.info("LocalSocketManager init");
+        this.channelSubClient.on("message", (channel, message) => {
+            this.logger.debug("channelSubClient: ", message, channel);
+            this.channelMessageListenner(message, channel);
+        });
+        this.subClient.on("message", (channel, message) => {
+            this.logger.debug("subClient: ", message, channel);
+            this.socketMessageListener(message, channel);
+        });
+    }
+    exit() {
+        this.logger.info("LocalSocketManager exit");
+    }
+    channelMessageListenner(message, channel) {
+        this.logger.debug("Receiving message from channel", channel, message);
+        const socketMessage = JSON.parse(message);
+        //-- only broadcast plain message
+        if (socketMessage.type === MessageType.PLAIN) {
+            this.allSockets.forEach((socket) => {
+                //-- socket.send will check for necessary permission
+                socket.send(socketMessage.data.message, socketMessage.data.channel);
+            });
+        }
+    }
+    socketMessageListener(message, channel) {
+        this.logger.debug("Receiving message from remote socket channel", channel, message);
+        const socketId = channel.substring(this.getSocketChannelKeyPrefix().length);
+        //-- find the socket
+        const socket = this.allSockets.find((s) => s.getId() === socketId);
+        if (socket) {
+            //-- handle message
+            const command = JSON.parse(message);
+            switch (command.type) {
+                case RedisSocketCommand.SEND:
+                    socket.physicSend(command.data);
+                    break;
+                case RedisSocketCommand.SAVE:
+                    socket.socketInfo.channels = command.data;
+                    socket.saveSocketInfo();
+                    break;
+                case RedisSocketCommand.CLOSE:
+                    socket.disconnect(command.data);
+                    break;
+                default:
+                    //-- ignore
+                    this.logger.debug("Invalid remote command", command);
+                    break;
+            }
+        }
+    }
+    getUniqueDataChannelName(channel) {
+        return `CHANNEL_DATA:${channel}`;
+    }
+    getSocketChannelKeyPrefix() {
+        return "SOCKET_CHANNEL:";
+    }
+    getSocketChannelKey(socketId) {
+        return `${this.getSocketChannelKeyPrefix()}${socketId}`;
+    }
+    async broadcastToChannel(channel, data) {
+        const formattedData = this.formatBroadcastData(channel, data);
+        await this.redisClient.publish(this.getUniqueDataChannelName(channel), JSON.stringify(formattedData));
+    }
+    async addSocketToChannel(socketId, channelInfos) {
+        const socket = await super.addSocketToChannel(socketId, channelInfos);
+        const notYetSubscribed = channelInfos.map((c) => c.name).filter((c) => !this.subscribedChannels.includes(c));
+        if (notYetSubscribed.length) {
+            await Promise.all(notYetSubscribed.map((channelName) => {
+                return this.channelSubClient.subscribe(this.getUniqueDataChannelName(channelName));
+            }));
+            this.subscribedChannels.push(...notYetSubscribed);
+        }
+        return socket;
+    }
+    async removeSocketFromChannel(socketId, channels, persist = true) {
+        await super.removeSocketFromChannel(socketId, channels, persist);
+        await Promise.all(channels.map((channel) => this.channelSubClient.unsubscribe(this.getUniqueChannelName(channel))));
+        this.subscribedChannels = this.subscribedChannels.filter((c) => !channels.includes(c));
+    }
+    async addSocket(socketInfo, { socket }) {
+        const expressSocket = new ExpressSocket(this, socket, socketInfo, async (socketInfo) => {
+            await this.redisClient.hset(this.getSocketInfoHashKey(), socketInfo.id, JSON.stringify(socketInfo));
+        });
+        //-- create a channel on redis for cross-instance communication
+        const channelKey = this.getSocketChannelKey(socketInfo.id);
+        //-- subscribe to that channel
+        await this.subClient.subscribe(channelKey);
+        this.allSockets.push(expressSocket);
+        return expressSocket;
+    }
+    async removeSocket(socketId, physicRemove = true) {
+        await super.removeSocket(socketId, physicRemove);
+        //-- unsubscribe from that channel
+        const channelKey = this.getSocketChannelKey(socketId);
+        await this.subClient.unsubscribe(channelKey);
+        //-- filter out socket
+        this.allSockets = this.allSockets.filter((s) => s.getId() !== socketId);
+    }
+    async getById(socketId) {
+        let socket = this.allSockets.find((s) => s.getId() === socketId);
+        if (!socket) {
+            //-- check redis
+            const socketInfo = await new Promise((resolve) => this.redisClient
+                .hget(this.getSocketInfoHashKey(), socketId)
+                .then((data) => resolve(data ? JSON.parse(data) : undefined))
+                .catch((err) => {
+                this.logger.error(err);
+                resolve(undefined);
+            }));
+            //-- if found then create redis socket
+            if (socketInfo) {
+                socket = new RedisSocket(this.getSocketChannelKey(socketId), this.sendClient, socketInfo);
+            }
+        }
+        return socket;
+    }
+    async getSocketsByChannel(channel) {
+        //-- get socket ids
+        const ids = await this.getSocketIdsOfChannel(channel);
+        const sockets = await Promise.all(ids.map((id) => this.getById(id)));
+        return sockets.filter((s) => !!s);
+    }
+    configure(httpServer) {
+        if (!httpServer) {
+            return;
+        }
+        this.logger.debug("Local socket manager configure");
+        const socketServer = new WebSocket.Server({ server: httpServer });
+        socketServer.on("connection", (socket, req) => {
+            const socketId = req.headers["sec-websocket-key"];
+            let socketReady = false;
+            let bufferMessages = [];
+            //-- call handle connection
+            const result = parseurl({ url: req.url });
+            const query = queryString.parse(decodeURIComponent(result.search || ""));
+            this.handle({
+                method: SocketMethod.CONNECT,
+                socketId: socketId,
+                data: { queries: query, socket },
+            })
+                .then(() => {
+                socketReady = true;
+                for (const m of bufferMessages) {
+                    this.handle(m).catch((err) => {
+                        this.logger.error(err);
+                    });
+                }
+            })
+                .catch((err) => {
+                //-- free up buffered messages
+                bufferMessages = [];
+                //-- close with code 1000
+                socket.close(1000, `${err.name}:${err.message}`);
+            });
+            socket.onmessage = (event) => {
+                const data = {
+                    method: SocketMethod.MESSAGE,
+                    socketId: socketId,
+                    data: event.data && JSON.parse(event.data),
+                };
+                if (socketReady) {
+                    this.handle(data).catch((err) => {
+                        this.logger.error(err);
+                    });
+                }
+                else {
+                    bufferMessages.push(data);
+                }
+            };
+            socket.onclose = () => {
+                this.handle({
+                    method: SocketMethod.DISCONNECT,
+                    socketId: socketId,
+                }).catch((err) => {
+                    this.logger.error(err);
+                });
+            };
+        });
+    }
+};
+LocalSocketManager = __decorate([
+    Initable(),
+    LogContext(),
+    __metadata("design:paramtypes", [Boolean, Redis,
+        Redis,
+        Redis,
+        AbstractLogger,
+        AbstractPrincipalResolver,
+        AbstractRequestAuthorizer])
+], LocalSocketManager);
+export { LocalSocketManager };

package/dist/system/ClaireServer.js

@@ -0,0 +1,78 @@
+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, ClaireApp, LogContext, getGlobalStore } from "@clairejs/core";
+import { ExitCode } from "../common/constants";
+import { AbstractHttpRequestHandler } from "../http/controller/AbstractHttpRequestHandler";
+import { AbstractServerSocketManager } from "../socket/AbstractServerSocketManager";
+import { getEndpointId } from "../http/utils";
+let ClaireServer = class ClaireServer extends ClaireApp {
+    logger;
+    httpRequestHandler;
+    socketManager;
+    booted = false;
+    constructor(logger, httpRequestHandler, socketManager) {
+        super();
+        this.logger = logger;
+        this.httpRequestHandler = httpRequestHandler;
+        this.socketManager = socketManager;
+    }
+    async init() {
+        if (this.booted) {
+            return;
+        }
+        const mountedEndpointInfo = [];
+        if (this.httpRequestHandler) {
+            const infos = await this.httpRequestHandler.getMountedEndpointInfo();
+            mountedEndpointInfo.push(...infos);
+        }
+        if (this.socketManager) {
+            const infos = await this.socketManager.getMountedEndpointInfo();
+            mountedEndpointInfo.push(...infos);
+        }
+        //-- save mounted endpoint info in server store to prevent circular dependency when resolving http request handler in controller
+        for (const endpoint of mountedEndpointInfo) {
+            this.logger.info(`Mounting: ${getEndpointId(endpoint.endpoint)}`);
+        }
+        getGlobalStore().mountedEndpointInfo = mountedEndpointInfo;
+        this.logger.debug("Claire server initing");
+        //-- handle exceptions
+        this.logger.debug(`Setting up exception handlers`);
+        process.on("SIGTERM", () => {
+            this.logger.warn("SIGTERM interrupt signal");
+            return this.stop(ExitCode.SIGTERM_INTERUPTION);
+        });
+        process.on("SIGINT", () => {
+            this.logger.warn("SIGINT interrupt signal");
+            return this.stop(ExitCode.SIGTERM_INTERUPTION);
+        });
+        process.on("uncaughtException", (err) => {
+            this.logger.error("uncaughtException", err.name, err.stack);
+        });
+        process.on("unhandledRejection", (err) => {
+            this.logger.error("unhandledRejection", err.name, err.stack);
+        });
+        this.booted = true;
+    }
+    exit() {
+        super.exit();
+    }
+    stop(code) {
+        this.logger.debug("Server is shutting down");
+        this.exit();
+        process.exit(code);
+    }
+};
+ClaireServer = __decorate([
+    LogContext(),
+    __metadata("design:paramtypes", [AbstractLogger,
+        AbstractHttpRequestHandler,
+        AbstractServerSocketManager])
+], ClaireServer);
+export { ClaireServer };

package/dist/system/ExpressWrapper.js

@@ -0,0 +1,122 @@
+import { Errors, getServiceProvider, SocketMethod } from "@clairejs/core";
+import express from "express";
+import http from "http";
+import cookieParser from "cookie-parser";
+import expressFileUpload from "express-fileupload";
+import cors from "cors";
+import { AbstractServerSocketManager } from "../socket/AbstractServerSocketManager";
+import { AbstractHttpRequestHandler } from "../http/controller/AbstractHttpRequestHandler";
+export class ExpressWrapper {
+    server;
+    config;
+    injector = getServiceProvider().getInjector();
+    socketManager;
+    httpRequestHandler;
+    httpServer;
+    constructor(server, config) {
+        this.server = server;
+        this.config = config;
+        this.socketManager = this.injector.resolveOptional(AbstractServerSocketManager);
+        this.httpRequestHandler = this.injector.resolveOptional(AbstractHttpRequestHandler);
+    }
+    close() {
+        this.httpServer?.close();
+        this.server.exit();
+    }
+    async listen(listenPort) {
+        await this.server.init();
+        await this.injector.initInstances();
+        const app = express();
+        //-- setup http listener
+        const httpServer = http.createServer(app);
+        this.socketManager?.configure(httpServer);
+        if (this.httpRequestHandler?.corsConfig) {
+            app.use(cors({
+                allowedHeaders: this.httpRequestHandler.corsConfig.headers,
+                credentials: this.httpRequestHandler.corsConfig.credentials,
+                origin: this.httpRequestHandler.corsConfig.origins,
+                methods: this.httpRequestHandler.corsConfig.methods,
+            }));
+        }
+        const requestLimitBytes = (this.config?.requestSetting?.maxBodySizeKB || 10240) * 1024;
+        app.use(cookieParser());
+        app.use(express.json({ limit: requestLimitBytes }));
+        app.use(express.urlencoded({ extended: false, limit: requestLimitBytes }));
+        app.use(expressFileUpload());
+        app.use((req, _res, next) => {
+            if (req.files) {
+                if (!req.body) {
+                    req.body = {};
+                }
+                Object.keys(req.files).forEach((file) => {
+                    req.body[file] = req.files[file];
+                });
+            }
+            next();
+        });
+        app.use(express.raw({
+            limit: requestLimitBytes,
+            type: (req) => !["application/json", "application/x-www-form-urlencoded"].find((type) => req.headers["content-type"]?.includes(type)),
+        }));
+        app.all("*", (req, res) => {
+            (async () => {
+                const isAwsGatewaySocket = !!req.headers["x-amzn-apigateway-api-id"];
+                if (isAwsGatewaySocket) {
+                    if (!this.socketManager) {
+                        throw Errors.SYSTEM_ERROR("Socket manager not found");
+                    }
+                    const socketData = {
+                        socketId: req.body.connectionId,
+                        data: req.body.data,
+                        method: req.body.type.toLowerCase(),
+                    };
+                    //-- if connect method then send url for authentication parsing
+                    if (socketData.method === SocketMethod.CONNECT) {
+                        //-- parse querystring, the query string has format of: "{p1=v1, p2=v2}"
+                        const queryString = req.body.data.querystring;
+                        const queries = queryString
+                            .substring(1, queryString.length - 1)
+                            .split(",")
+                            .map((pair) => pair.trim().split("="))
+                            .reduce((collector, pair) => Object.assign(collector, { [pair[0]]: pair[1] }), {});
+                        socketData.data = { queries };
+                    }
+                    await this.socketManager.handle(socketData);
+                    //-- send success response
+                    res.status(200).send();
+                }
+                else {
+                    if (!this.httpRequestHandler) {
+                        throw Errors.SYSTEM_ERROR("Http request handler not found");
+                    }
+                    const httpData = {
+                        clientIP: req.ip || req.headers["x-forwarded-for"],
+                        fullPath: req.url,
+                        method: req.method.toLowerCase(),
+                        headers: req.headers,
+                        body: req.body,
+                        cookies: req.cookies,
+                    };
+                    //-- handle options
+                    const result = await this.httpRequestHandler.handle(httpData);
+                    if (result.headers) {
+                        Object.keys(result.headers).forEach((key) => {
+                            res.set(key, result.headers[key]);
+                        });
+                    }
+                    if (result.cookies) {
+                        Object.keys(result.cookies).forEach((key) => {
+                            res.cookie(key, result.cookies[key].value, result.cookies[key].options || {});
+                        });
+                    }
+                    res.status(result.code || 200).send(result.value);
+                }
+            })().catch((err) => {
+                res.status(err.code || 500).json({ name: err.name, message: err.message, code: err.code || 500 });
+            });
+        });
+        return new Promise((resolve, reject) => {
+            this.httpServer = httpServer.listen(listenPort, resolve).on("error", reject);
+        });
+    }
+}

package/dist/system/LambdaWrapper.js

@@ -0,0 +1,151 @@
+import { getServiceProvider, HttpMethod, SocketMethod, Errors } from "@clairejs/core";
+import { AbstractHttpRequestHandler } from "../http/controller/AbstractHttpRequestHandler";
+import { AwsJobScheduler } from "../job/AwsJobScheduler";
+import { CRON_REQUEST_METHOD, INTERVAL_REQUEST_METHOD } from "../job/interfaces";
+import { AbstractServerSocketManager } from "../socket/AbstractServerSocketManager";
+const convertCorsToHeaders = (origin, cors) => {
+    const headers = {};
+    if (cors?.credentials) {
+        headers["Access-Control-Allow-Credentials"] = "true";
+    }
+    if (cors?.headers) {
+        headers["Access-Control-Allow-Headers"] =
+            typeof cors.headers === "string" ? cors.headers : cors.headers.join(", ");
+    }
+    if (cors?.methods) {
+        headers["Access-Control-Allow-Methods"] =
+            typeof cors.methods === "string" ? cors.methods : cors.methods.join(", ");
+    }
+    if (cors?.origins) {
+        headers["Access-Control-Allow-Origin"] =
+            typeof cors.origins === "string"
+                ? cors.origins
+                : cors.origins.find((org) => origin.match(org))
+                    ? origin
+                    : "";
+    }
+    return headers;
+};
+const toApiGatewayFormat = (response) => ({
+    statusCode: response.code || 200,
+    body: response.value && JSON.stringify(response.value),
+    headers: response.headers,
+    cookies: Object.keys(response.cookies || {}).map((key) => {
+        const cookieValue = response.cookies[key];
+        let base = `${key}=${cookieValue.value}`;
+        if (cookieValue.options?.maxAge) {
+            base += `; MaxAge=${cookieValue.options.maxAge}`;
+        }
+        if (cookieValue.options?.expires) {
+            base += `; Expires=${cookieValue.options.expires.toUTCString()}`;
+        }
+        if (cookieValue.options?.httpOnly) {
+            base += `; HttpOnly`;
+        }
+        if (cookieValue.options?.path) {
+            base += `; Path=${cookieValue.options?.path}`;
+        }
+        if (cookieValue.options?.domain) {
+            base += `; Domain=${cookieValue.options?.domain}`;
+        }
+        if (cookieValue.options?.secure) {
+            base += `; Secure`;
+        }
+        if (cookieValue.options?.sameSite) {
+            if (typeof cookieValue.options?.sameSite === "boolean") {
+                base += `; SameSite`;
+            }
+            else {
+                base += `; SameSite=${cookieValue.options?.sameSite}`;
+            }
+        }
+        return base;
+    }),
+});
+export class LambdaWrapper {
+    serverFactory;
+    requestMapper;
+    config;
+    injector = getServiceProvider().getInjector();
+    httpRequestHandler;
+    socketManager;
+    jobScheduler;
+    _server;
+    constructor(serverFactory, requestMapper, config) {
+        this.serverFactory = serverFactory;
+        this.requestMapper = requestMapper;
+        this.config = config;
+        this.handler = this.handler.bind(this);
+        this.socketManager = this.injector.resolveOptional(AbstractServerSocketManager);
+        this.httpRequestHandler = this.injector.resolveOptional(AbstractHttpRequestHandler);
+        this.jobScheduler = this.injector.resolveOptional(AwsJobScheduler);
+    }
+    async bootServer() {
+        if (!this._server) {
+            this._server = await this.serverFactory();
+            await this.injector.initInstances();
+            this.socketManager?.configure();
+            await this._server.init();
+        }
+    }
+    async handler(event) {
+        await this.bootServer();
+        //-- handle http otherwise
+        const requestOptions = this.requestMapper(event);
+        if (!requestOptions) {
+            throw Errors.SYSTEM_ERROR("Cannot resolve event");
+        }
+        const corsHeaders = convertCorsToHeaders(requestOptions.headers?.origin || "", this.httpRequestHandler?.corsConfig);
+        if (requestOptions.method === HttpMethod.OPTIONS) {
+            return toApiGatewayFormat({ code: 200, headers: corsHeaders, cookies: {} });
+        }
+        if (requestOptions.method === INTERVAL_REQUEST_METHOD) {
+            await this.jobScheduler?.handleInterval(requestOptions.body);
+            return toApiGatewayFormat({ code: 200, headers: corsHeaders, cookies: {} });
+        }
+        if (requestOptions.method === CRON_REQUEST_METHOD) {
+            await this.jobScheduler?.handleCron(requestOptions.body);
+            return toApiGatewayFormat({ code: 200, headers: corsHeaders, cookies: {} });
+        }
+        try {
+            if (Object.values(HttpMethod).includes(requestOptions.method)) {
+                if (!this.httpRequestHandler) {
+                    throw Errors.SYSTEM_ERROR("Http request handler not found");
+                }
+                const httpData = {
+                    clientIP: requestOptions.clientIP,
+                    fullPath: requestOptions.rawPath,
+                    method: requestOptions.method,
+                    headers: requestOptions.headers,
+                    cookies: requestOptions.cookies,
+                    body: requestOptions.body,
+                };
+                const response = await this.httpRequestHandler.handle(httpData);
+                return toApiGatewayFormat({ ...response, headers: { ...corsHeaders, ...response.headers } });
+            }
+            else if (Object.values(SocketMethod).includes(requestOptions.method)) {
+                if (!this.socketManager) {
+                    throw Errors.SYSTEM_ERROR("Socket manager not found");
+                }
+                const socketData = {
+                    socketId: requestOptions.rawPath,
+                    method: requestOptions.method,
+                    data: requestOptions.body,
+                };
+                await this.socketManager.handle(socketData);
+            }
+            else {
+                throw Errors.HTTP_REQUEST_ERROR("Not allow request method: " + requestOptions.method);
+            }
+            return toApiGatewayFormat({ code: 200, headers: corsHeaders, cookies: {} });
+        }
+        catch (err) {
+            return toApiGatewayFormat({
+                code: err.code || 500,
+                value: { name: err.name, message: err.message, code: err.code || 500 },
+                headers: corsHeaders,
+                cookies: {},
+            });
+        }
+    }
+}

package/dist/system/ServerGlobalStore.js

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