@wabot-dev/framework 0.2.0-beta.1 → 0.2.0-beta.11

package/dist/src/addon/auth/api-key/@apiKeyHandshakeGuard.js

@@ -0,0 +1,16 @@
+import { handshakeMiddlewares } from '../../../feature/socket-controller/metadata/@handshakeMiddlewares.js';
+import '../../../feature/socket-controller/metadata/SocketControllerMetadataStore.js';
+import '../../../core/injection/index.js';
+import 'debug';
+import '../../../core/validation/metadata/ValidationMetadataStore.js';
+import 'socket.io';
+import '../../../feature/socket/SocketServerProvider.js';
+import { ApiKeyHandshakeGuardMiddleware } from './ApiKeyHandshakeGuardMiddleware.js';
+
+function apiKeyHandshakeGuard() {
+    return function (target) {
+        handshakeMiddlewares([ApiKeyHandshakeGuardMiddleware])(target);
+    };
+}
+
+export { apiKeyHandshakeGuard };

package/dist/src/addon/auth/api-key/ApiKey.js

@@ -13,6 +13,9 @@ class ApiKey extends Entity {
     get metadata() {
         return this.data.metadata ?? {};
     }
+    get name() {
+        return this.data.name;
+    }
     setAuthInfo(authInfo) {
         this.data.authInfo = authInfo;
     }

package/dist/src/addon/auth/api-key/ApiKeyGuardMiddleware.js

@@ -21,10 +21,7 @@ let ApiKeyGuardMiddleware = class ApiKeyGuardMiddleware {
             throw new CustomError({ httpCode: 401, message: 'Authorization should be an Api-Key' });
         }
         try {
-            const authInfo = await this.apiKeyRepository.findAuthInfoBySecret(keySecret);
-            if (!authInfo) {
-                throw new CustomError({ httpCode: 401, message: 'Invalid key' });
-            }
+            const authInfo = await this.apiKeyRepository.findAndValidate(keySecret);
             this.auth.assign(authInfo);
         }
         catch (err) {

package/dist/src/addon/auth/api-key/{ApiKeyConnectionGuardMiddleware.js → ApiKeyHandshakeGuardMiddleware.js}

@@ -4,7 +4,7 @@ import { CustomError } from '../../../core/error/CustomError.js';
 import { injectable } from '../../../core/injection/index.js';
 import { ApiKeyRepository } from './ApiKeyRepository.js';
 
-let ApiKeyConnectionGuardMiddleware = class ApiKeyConnectionGuardMiddleware {
+let ApiKeyHandshakeGuardMiddleware = class ApiKeyHandshakeGuardMiddleware {
     apiKeyRepository;
     auth;
     constructor(apiKeyRepository, auth) {
@@ -33,10 +33,7 @@ let ApiKeyConnectionGuardMiddleware = class ApiKeyConnectionGuardMiddleware {
             throw new CustomError({ httpCode: 401, message: 'Token not available' });
         }
         try {
-            const authInfo = await this.apiKeyRepository.findAuthInfoBySecret(keySecret);
-            if (!authInfo) {
-                throw new CustomError({ httpCode: 401, message: 'Invalid token' });
-            }
+            const authInfo = await this.apiKeyRepository.findAndValidate(keySecret);
             this.auth.assign(authInfo);
         }
         catch (err) {
@@ -48,10 +45,10 @@ let ApiKeyConnectionGuardMiddleware = class ApiKeyConnectionGuardMiddleware {
         }
     }
 };
-ApiKeyConnectionGuardMiddleware = __decorate([
+ApiKeyHandshakeGuardMiddleware = __decorate([
     injectable(),
     __metadata("design:paramtypes", [ApiKeyRepository,
         Auth])
-], ApiKeyConnectionGuardMiddleware);
+], ApiKeyHandshakeGuardMiddleware);
 
-export { ApiKeyConnectionGuardMiddleware };
+export { ApiKeyHandshakeGuardMiddleware };

package/dist/src/addon/auth/api-key/ApiKeyRepository.js

@@ -1,20 +1,23 @@
 class ApiKeyRepository {
-    findAuthInfoBySecret(secret) {
+    find(id) {
+        throw new Error('Method not implemented.');
+    }
+    findOrThrow(id) {
         throw new Error('Method not implemented.');
     }
     findByMetadata(metadata) {
         throw new Error('Method not implemented.');
     }
-    find(id) {
+    create(item) {
         throw new Error('Method not implemented.');
     }
-    findOrThrow(id) {
+    generate(req) {
         throw new Error('Method not implemented.');
     }
-    create(item) {
+    findBySecret(secret) {
         throw new Error('Method not implemented.');
     }
-    generate(req) {
+    findAndValidate(secret) {
         throw new Error('Method not implemented.');
     }
 }

package/dist/src/addon/auth/api-key/PgApiKeyRepository.js

@@ -3,6 +3,7 @@ import { PgCrudRepository } from '../../../feature/pg/PgCrudRepository.js';
 import { Pool } from 'pg';
 import { singleton } from 'tsyringe';
 import { ApiKey } from './ApiKey.js';
+import { CustomError } from '../../../core/error/CustomError.js';
 
 let PgApiKeyRepository = class PgApiKeyRepository extends PgCrudRepository {
     constructor(pool) {
@@ -12,7 +13,14 @@ let PgApiKeyRepository = class PgApiKeyRepository extends PgCrudRepository {
             constructor: ApiKey,
         });
     }
-    async findAuthInfoBySecret(secret) {
+    async findAndValidate(secret) {
+        const apiKey = await this.findBySecret(secret);
+        if (!apiKey) {
+            throw new CustomError({ message: 'Invalid Api Key', httpCode: 401 });
+        }
+        return apiKey.authInfo;
+    }
+    async findBySecret(secret) {
         const secretHash = ApiKey.hashSecret(secret);
         const query = `
       SELECT ${this.columns}
@@ -21,7 +29,7 @@ let PgApiKeyRepository = class PgApiKeyRepository extends PgCrudRepository {
       LIMIT 1
     `;
         const items = await this.query(query, [JSON.stringify({ secretHash })]);
-        return items[0]?.authInfo ?? null;
+        return items[0] ?? null;
     }
     async findByMetadata(metadata) {
         const query = `

package/dist/src/addon/auth/api-key/RemoteApiKeyRepository.js

@@ -3,42 +3,21 @@ import { CustomError } from '../../../core/error/CustomError.js';
 class RemoteApiKeyRepository {
     fetcher;
     cacheSeconds;
-    cacheById = new Map();
     cacheBySecret = new Map();
     constructor(fetcher, cacheSeconds) {
         this.fetcher = fetcher;
         this.cacheSeconds = cacheSeconds;
     }
-    async find(id) {
-        const now = Date.now();
-        const cached = this.cacheById.get(id);
-        if (cached && cached.expiresAt > now) {
-            return cached.value;
-        }
-        const result = await this.fetcher.fetchById(id);
-        this.cacheById.set(id, {
-            value: result,
-            expiresAt: now + this.cacheSeconds * 1000,
-        });
-        return result;
-    }
-    async findOrThrow(id) {
-        const result = await this.find(id);
-        if (!result) {
-            throw new Error(`API key with ID '${id}' not found.`);
-        }
-        return result;
-    }
-    async findAuthInfoBySecret(secret) {
+    async findAndValidate(secret) {
         const now = Date.now();
         const cached = this.cacheBySecret.get(secret);
         if (cached && cached.expiresAt > now) {
             if (!cached.value) {
                 throw new CustomError({ message: 'Invalid Api Key', httpCode: 401 });
             }
-            return cached.value.authInfo;
+            return cached.value;
         }
-        const result = await this.fetcher.fetchBySecret(secret);
+        const result = await this.fetcher.fetchAuthInfoBySecret(secret);
         this.cacheBySecret.set(secret, {
             value: result,
             expiresAt: now + this.cacheSeconds * 1000,
@@ -46,7 +25,16 @@ class RemoteApiKeyRepository {
         if (!result) {
             throw new CustomError({ message: 'Invalid Api Key', httpCode: 401 });
         }
-        return result.authInfo;
+        return result;
+    }
+    find(id) {
+        throw new Error('Method not implemented.');
+    }
+    findOrThrow(id) {
+        throw new Error('Method not implemented.');
+    }
+    findBySecret(secret) {
+        throw new Error('Method not implemented.');
     }
     findByMetadata(metadata) {
         throw new Error('Method not implemented.');

package/dist/src/addon/auth/jwt/@jwtHandshakeGuard.js

@@ -0,0 +1,16 @@
+import { handshakeMiddlewares } from '../../../feature/socket-controller/metadata/@handshakeMiddlewares.js';
+import '../../../feature/socket-controller/metadata/SocketControllerMetadataStore.js';
+import '../../../core/injection/index.js';
+import 'debug';
+import '../../../core/validation/metadata/ValidationMetadataStore.js';
+import 'socket.io';
+import '../../../feature/socket/SocketServerProvider.js';
+import { JwtHandshakeGuardMiddleware } from './JwtHandshakeGuardMiddleware.js';
+
+function jwtHandshakeGuard() {
+    return function (target) {
+        handshakeMiddlewares([JwtHandshakeGuardMiddleware])(target);
+    };
+}
+
+export { jwtHandshakeGuard };

package/dist/src/addon/auth/jwt/Jwt.js

@@ -17,17 +17,18 @@ let Jwt = class Jwt {
         this.jwtRefreshTokenRepository = jwtRefreshTokenRepository;
         this.config = config;
     }
-    async createToken() {
+    async createToken(metadata) {
         const authInfo = this.auth.require();
         const refreshToken = new JwtRefreshToken({
+            metadata,
             authInfo,
-            expirationTime: new Date().getTime() + this.config.refreshExpirationSeconds * 1000,
+            expirationTime: Date.now() + this.config.refreshExpirationSeconds * 1000,
         });
-        const refreshPassword = refreshToken.generatePassword();
+        const refreshSecret = refreshToken.generateSecret();
         await this.jwtRefreshTokenRepository.create(refreshToken);
         const access = await this.jwtSigner.signAccessToken(refreshToken);
         const refresh = {
-            token: JwtRefreshToken.deflate({ id: refreshToken.id, pass: refreshPassword }),
+            token: refreshSecret,
             expiration: new Date(refreshToken.expirationTime),
         };
         return {
@@ -35,11 +36,8 @@ let Jwt = class Jwt {
             refresh,
         };
     }
-    async refreshToken(refreshSecret) {
-        const { id, pass } = JwtRefreshToken.inflate(refreshSecret);
-        const refreshToken = await this.jwtRefreshTokenRepository.findOrThrow(id);
-        refreshToken.validatePassword(pass);
-        return this.jwtSigner.signAccessToken(refreshToken);
+    async findRefreshTokenAuthInfo(secret) {
+        return await this.jwtRefreshTokenRepository.findAndValidate(secret);
     }
 };
 Jwt = __decorate([

package/dist/src/addon/auth/jwt/{JwtConnectionGuardMiddleware.js → JwtHandshakeGuardMiddleware.js}

@@ -5,7 +5,7 @@ import { Auth } from '../../../core/auth/Auth.js';
 import { CustomError } from '../../../core/error/CustomError.js';
 import { JwtConfig } from './JwtConfig.js';
 
-let JwtConnectionGuardMiddleware = class JwtConnectionGuardMiddleware {
+let JwtHandshakeGuardMiddleware = class JwtHandshakeGuardMiddleware {
     config;
     auth;
     constructor(config, auth) {
@@ -48,10 +48,10 @@ let JwtConnectionGuardMiddleware = class JwtConnectionGuardMiddleware {
         }
     }
 };
-JwtConnectionGuardMiddleware = __decorate([
+JwtHandshakeGuardMiddleware = __decorate([
     injectable(),
     __metadata("design:paramtypes", [JwtConfig,
         Auth])
-], JwtConnectionGuardMiddleware);
+], JwtHandshakeGuardMiddleware);
 
-export { JwtConnectionGuardMiddleware };
+export { JwtHandshakeGuardMiddleware };

package/dist/src/addon/auth/jwt/JwtRefreshToken.js

@@ -1,55 +1,60 @@
 import { Entity } from '../../../core/entity/Entity.js';
 import { CustomError } from '../../../core/error/CustomError.js';
-import { Password } from '../../../core/password/Password.js';
+import crypto from 'node:crypto';
 
 class JwtRefreshToken extends Entity {
+    static PREFIX = 'rt_';
+    static hashSecret(secret) {
+        return crypto.createHash('sha256').update(secret).digest('hex');
+    }
     get authInfo() {
         return this.data.authInfo;
     }
+    get metadata() {
+        return this.data.metadata ?? {};
+    }
     get expirationTime() {
         return new Date(this.data.expirationTime);
     }
-    generatePassword() {
-        if (this.data.passwordHash) {
-            throw new Error('This api key, already has a secret');
+    isExpired() {
+        return Date.now() > this.data.expirationTime;
+    }
+    revoke() {
+        this.data.revokedAt = Date.now();
+    }
+    isRevoked() {
+        return this.data.revokedAt != null;
+    }
+    generateSecret() {
+        if (this.data.secretHash) {
+            throw new Error('This Token key already has a secret');
         }
-        const password = Password.generate(64);
-        this.data.passwordHash = Password.hash({ password: password });
-        return password;
+        const secret = `${JwtRefreshToken.PREFIX}${crypto.randomBytes(32).toString('hex')}`;
+        this.data.secretHash = JwtRefreshToken.hashSecret(secret);
+        return secret;
     }
-    isValidPassword(password) {
-        if (new Date().getTime() > this.data.expirationTime) {
+    isValidSecret(secret) {
+        if (!secret.startsWith(JwtRefreshToken.PREFIX))
             return false;
-        }
-        if (!this.data.passwordHash)
+        if (!this.data.secretHash)
             return false;
-        return Password.isValid({ password: password, hash: this.data.passwordHash });
+        const hashed = JwtRefreshToken.hashSecret(secret);
+        const stored = this.data.secretHash;
+        const hashedBuf = Buffer.from(hashed, 'hex');
+        const storedBuf = Buffer.from(stored, 'hex');
+        return hashedBuf.length === storedBuf.length && crypto.timingSafeEqual(hashedBuf, storedBuf);
     }
-    validatePassword(password) {
-        if (!this.isValidPassword(password)) {
-            throw new CustomError({ message: 'Invalid Api key', httpCode: 401 });
-        }
-    }
-    static inflate(secret) {
-        try {
-            const json = Buffer.from(secret, 'base64').toString('utf-8');
-            const data = JSON.parse(json);
-            if (!data.id || !data.pass) {
-                throw new Error('invalid secret structure');
-            }
-            return data;
-        }
-        catch (err) {
-            throw new Error('fail to inflate secret: ' + err.message);
-        }
+    isValidToken(secret) {
+        if (this.isExpired())
+            return false;
+        if (this.isRevoked())
+            return false;
+        return this.isValidSecret(secret);
     }
-    static deflate(data) {
-        const { id, pass } = data;
-        if (!id || !pass) {
-            throw new Error('id and pass required');
+    validateToken(secret) {
+        if (!this.isValidToken(secret)) {
+            throw new CustomError({ message: 'Invalid Token', httpCode: 401 });
         }
-        const json = JSON.stringify({ id, pass });
-        return Buffer.from(json, 'utf-8').toString('base64');
     }
 }
 

package/dist/src/addon/auth/jwt/JwtRefreshTokenRepository.js

@@ -1,4 +1,10 @@
 class JwtRefreshTokenRepository {
+    findByMetadata(metadata) {
+        throw new Error('Method not implemented.');
+    }
+    findAndValidate(secret) {
+        throw new Error('Method not implemented.');
+    }
     find(id) {
         throw new Error('Method not implemented.');
     }

package/dist/src/addon/auth/jwt/JwtSigner.js

@@ -23,7 +23,7 @@ let JwtSigner = class JwtSigner {
         const token = jwt.sign(_authInfo, this.config.secretOrPrivateKey, {
             expiresIn: this.config.accessExpirationSeconds,
         });
-        const expiration = new Date().getTime() + this.config.accessExpirationSeconds * 1000;
+        const expiration = new Date(new Date().getTime() + this.config.accessExpirationSeconds * 1000);
         return this.mapper.map({ token, expiration }, JwtTokenDto);
     }
 };

package/dist/src/addon/auth/jwt/PgJwtRefreshTokenRepository.js

@@ -3,6 +3,7 @@ import { singleton } from '../../../core/injection/index.js';
 import { Pool } from 'pg';
 import { PgCrudRepository } from '../../../feature/pg/PgCrudRepository.js';
 import { JwtRefreshToken } from './JwtRefreshToken.js';
+import { CustomError } from '../../../core/error/CustomError.js';
 
 let PgJwtRefreshTokenRepository = class PgJwtRefreshTokenRepository extends PgCrudRepository {
     constructor(pool) {
@@ -12,6 +13,32 @@ let PgJwtRefreshTokenRepository = class PgJwtRefreshTokenRepository extends PgCr
             constructor: JwtRefreshToken,
         });
     }
+    async findAndValidate(secret) {
+        const apiKey = await this.findBySecret(secret);
+        if (!apiKey) {
+            throw new CustomError({ message: 'Invalid Token', httpCode: 401 });
+        }
+        return apiKey.authInfo;
+    }
+    async findBySecret(secret) {
+        const secretHash = JwtRefreshToken.hashSecret(secret);
+        const query = `
+        SELECT ${this.columns}
+        FROM ${this.table}
+        WHERE data @> $1::jsonb
+        LIMIT 1
+      `;
+        const items = await this.query(query, [JSON.stringify({ secretHash })]);
+        return items[0] ?? null;
+    }
+    async findByMetadata(metadata) {
+        const query = `
+        SELECT ${this.columns}
+        FROM ${this.table}
+        WHERE data @> $1::jsonb
+      `;
+        return await this.query(query, [JSON.stringify({ metadata })]);
+    }
 };
 PgJwtRefreshTokenRepository = __decorate([
     singleton(),

package/dist/src/addon/chat-controller/cmd/CmdChannel.js

@@ -1,14 +1,16 @@
-import { __decorate } from 'tslib';
+import { __decorate, __metadata } from 'tslib';
 import { injectable } from '../../../core/injection/index.js';
 import * as readline from 'readline';
 import * as fs from 'fs';
 import * as path from 'path';
 import { Random } from '../../../core/random/Random.js';
+import { Auth } from '../../../core/auth/Auth.js';
 
 var CmdChannel_1;
 const chatIdPath = '.cmd-channel/id.json';
 const authInfoPath = '.cmd-channel/auth-info.json';
 let CmdChannel = CmdChannel_1 = class CmdChannel {
+    auth;
     authInfo = undefined;
     chatId = undefined;
     rl = readline.createInterface({
@@ -16,6 +18,9 @@ let CmdChannel = CmdChannel_1 = class CmdChannel {
         output: process.stdout,
     });
     callBack = null;
+    constructor(auth) {
+        this.auth = auth;
+    }
     listen(callback) {
         this.callBack = callback;
     }
@@ -55,18 +60,18 @@ let CmdChannel = CmdChannel_1 = class CmdChannel {
                 reply: (message) => {
                     console.log(`\n[${message.senderName}]: ${message.text}\n`);
                     this.rl.prompt();
+                    if (this.auth.isAssigned()) {
+                        writeJsonToFile(authInfoPath, this.auth.require());
+                    }
                 },
-                authInfo: this.authInfo || undefined,
-                setAuthInfo: (authInfo) => {
-                    this.authInfo = authInfo || null;
-                    writeJsonToFile(authInfoPath, this.authInfo);
-                },
+                injectInstances: [[Auth, this.auth]],
             });
         });
     }
 };
 CmdChannel = CmdChannel_1 = __decorate([
-    injectable()
+    injectable(),
+    __metadata("design:paramtypes", [Auth])
 ], CmdChannel);
 function writeJsonToFile(filename, data) {
     const filePath = path.resolve(process.cwd(), filename);

package/dist/src/addon/chat-controller/socket/@socket.js

@@ -18,7 +18,7 @@ function socket(config) {
             channelConstructor: SocketChannel,
             functionName: propertyKey.toString(),
             controllerConstructor: target.constructor,
-            channelConfig: new SocketChannelConfig(config.channel),
+            channelConfig: new SocketChannelConfig(config.namespace, config.handshakeMidlewares),
         });
     };
 }

package/dist/src/addon/chat-controller/socket/SocketChannel.js

@@ -1,65 +1,106 @@
 import { __decorate, __metadata } from 'tslib';
 import { injectable } from '../../../core/injection/index.js';
-import { SocketServerProvider } from '../../../feature/socket/SocketServerProvider.js';
+import { handshakeMiddlewares } from '../../../feature/socket-controller/metadata/@handshakeMiddlewares.js';
+import { socketController } from '../../../feature/socket-controller/metadata/@socketController.js';
+import { onSocketEvent } from '../../../feature/socket-controller/metadata/@onSocketEvent.js';
+import '../../../feature/socket-controller/metadata/SocketControllerMetadataStore.js';
+import { runSocketControllers } from '../../../feature/socket-controller/runSocketControllers.js';
+import { Socket } from 'socket.io';
 import { SocketChannelConfig } from './SocketChannelConfig.js';
+import '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { isNotEmpty } from '../../../core/validation/validators/is-not-empty/@isNotEmpty.js';
+import { isString } from '../../../core/validation/validators/is-string/@isString.js';
+import { Auth } from '../../../core/auth/Auth.js';
 
 var SocketChannel_1;
+class SocketChannelReceivedMessage {
+    chatId;
+    senderName;
+    text;
+}
+__decorate([
+    isString(),
+    isNotEmpty(),
+    __metadata("design:type", String)
+], SocketChannelReceivedMessage.prototype, "chatId", void 0);
+__decorate([
+    isString(),
+    isNotEmpty(),
+    __metadata("design:type", String)
+], SocketChannelReceivedMessage.prototype, "senderName", void 0);
+__decorate([
+    isString(),
+    isNotEmpty(),
+    __metadata("design:type", String)
+], SocketChannelReceivedMessage.prototype, "text", void 0);
 let SocketChannel = SocketChannel_1 = class SocketChannel {
     config;
-    socketServerProvider;
     callBack = null;
-    server;
-    constructor(config, socketServerProvider) {
+    controller = null;
+    constructor(config) {
         this.config = config;
-        this.socketServerProvider = socketServerProvider;
-        this.server = this.socketServerProvider.getSocketServer();
+        this.configController();
     }
-    listen(callback) {
-        this.callBack = callback;
-    }
-    connect() {
-        this.server.on('connection', (socket) => {
-            socket.on(this.config.channel, async (message) => {
+    configController() {
+        const channel = this;
+        let SocketChannelController = class SocketChannelController {
+            auth;
+            constructor(auth) {
+                this.auth = auth;
+            }
+            onMessage(message, socket) {
+                if (!channel.callBack)
+                    return;
                 const trimmedInput = message.text.trim();
                 if (!trimmedInput) {
                     return;
                 }
-                if (!message.chatId || !message.userId || !message.senderName) {
-                    socket.emit(this.config.channel, {
-                        error: 'Invalid message format. chatId, userId, and senderName are required.',
-                    });
-                    return;
-                }
                 const chatConnection = {
                     id: message.chatId,
                     chatType: 'PRIVATE',
                     channelName: SocketChannel_1.name,
                 };
-                if (!this.callBack)
-                    return;
-                this.callBack({
+                channel.callBack({
                     chatConnection,
                     message: {
-                        text: trimmedInput,
+                        text: message.text,
                         senderName: message.senderName,
                     },
                     reply: (message) => {
-                        socket.emit(this.config.channel, message);
-                    },
-                    authInfo: socket.data.authInfo,
-                    setAuthInfo: (authInfo) => {
-                        socket.data.authInfo = authInfo;
+                        socket.emit('message', message);
                     },
+                    injectInstances: [
+                        [Socket, socket],
+                        [Auth, this.auth],
+                    ],
                 });
-            });
-        });
-        this.socketServerProvider.listen();
+            }
+        };
+        __decorate([
+            onSocketEvent('message'),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [SocketChannelReceivedMessage, Socket]),
+            __metadata("design:returntype", void 0)
+        ], SocketChannelController.prototype, "onMessage", null);
+        SocketChannelController = __decorate([
+            socketController(channel.config.namespace),
+            handshakeMiddlewares(channel.config.handshakeMidlewares ?? []),
+            __metadata("design:paramtypes", [Auth])
+        ], SocketChannelController);
+        this.controller = SocketChannelController;
+    }
+    listen(callback) {
+        this.callBack = callback;
+    }
+    connect() {
+        if (!this.controller)
+            return;
+        runSocketControllers([this.controller]);
     }
 };
 SocketChannel = SocketChannel_1 = __decorate([
     injectable(),
-    __metadata("design:paramtypes", [SocketChannelConfig,
-        SocketServerProvider])
+    __metadata("design:paramtypes", [SocketChannelConfig])
 ], SocketChannel);
 
-export { SocketChannel };
+export { SocketChannel, SocketChannelReceivedMessage };

package/dist/src/addon/chat-controller/socket/SocketChannelConfig.js

@@ -2,14 +2,16 @@ import { __decorate, __metadata } from 'tslib';
 import { injectable } from '../../../core/injection/index.js';
 
 let SocketChannelConfig = class SocketChannelConfig {
-    channel;
-    constructor(channel) {
-        this.channel = channel;
+    namespace;
+    handshakeMidlewares;
+    constructor(namespace, handshakeMidlewares) {
+        this.namespace = namespace;
+        this.handshakeMidlewares = handshakeMidlewares;
     }
 };
 SocketChannelConfig = __decorate([
     injectable(),
-    __metadata("design:paramtypes", [String])
+    __metadata("design:paramtypes", [String, Array])
 ], SocketChannelConfig);
 
 export { SocketChannelConfig };