ts-game-decorators 1.0.4 → 1.0.6

package/dist/index.d.ts

@@ -6,8 +6,6 @@ export * from './db/couchbaseClient';
 export * from './db/lowdbClient';
 export * from './config/redis';
 export * from './utils/collisionDetector';
-export * from './utils/discordConnector';
-export * from './utils/teleConnector';
 export * from './utils/utils';
 export * from './types';
 export * from './types/map';

package/dist/index.js

@@ -27,8 +27,6 @@ __exportStar(require("./db/lowdbClient"), exports);
 __exportStar(require("./config/redis"), exports);
 // Utils
 __exportStar(require("./utils/collisionDetector"), exports);
-__exportStar(require("./utils/discordConnector"), exports);
-__exportStar(require("./utils/teleConnector"), exports);
 __exportStar(require("./utils/utils"), exports);
 // Types
 __exportStar(require("./types"), exports);

package/dist/lib/config/redis.d.ts

@@ -0,0 +1,7 @@
+export declare const createRedisAdapter: () => Promise<any>;
+export declare const getRedisAdapter: () => any;
+export declare const getRedisClients: () => {
+    pubClient: any;
+    subClient: any;
+};
+export declare const closeRedisConnections: () => Promise<void>;

package/dist/lib/config/redis.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.closeRedisConnections = exports.getRedisClients = exports.getRedisAdapter = exports.createRedisAdapter = void 0;
+const redis_1 = require("redis");
+const redis_adapter_1 = require("@socket.io/redis-adapter");
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';
+const REDIS_USERNAME = process.env.REDIS_USERNAME;
+const REDIS_PASSWORD = process.env.REDIS_PASSWORD;
+// Redis client instances for reuse
+let pubClient = null;
+let subClient = null;
+let redisAdapter = null;
+const createRedisAdapter = async () => {
+    try {
+        console.log('🔗 Connecting to Redis...');
+        // Build Redis client configuration
+        const redisConfig = {
+            url: REDIS_URL,
+            socket: {
+                reconnectStrategy: (retries) => {
+                    if (retries > 10) {
+                        console.error('❌ Redis: Too many retries, giving up');
+                        return new Error('Too many retries');
+                    }
+                    console.log(`🔄 Redis: Retrying connection (${retries}/10)`);
+                    return Math.min(retries * 100, 3000);
+                }
+            }
+        };
+        // Only add authentication if credentials are provided
+        if (REDIS_USERNAME) {
+            redisConfig.username = REDIS_USERNAME;
+        }
+        if (REDIS_PASSWORD) {
+            redisConfig.password = REDIS_PASSWORD;
+        }
+        console.log(`🔗 Redis config: ${REDIS_URL} ${REDIS_USERNAME ? `(username: ${REDIS_USERNAME})` : ''} ${REDIS_PASSWORD ? '(password: ***)' : '(no auth)'}`);
+        // Create publisher client
+        pubClient = (0, redis_1.createClient)(redisConfig);
+        // Create subscriber client (duplicate of publisher)
+        subClient = pubClient.duplicate();
+        // Error handling for publisher
+        pubClient.on('error', (err) => {
+            console.error('❌ Redis Publisher Error:', err);
+        });
+        pubClient.on('connect', () => {
+            console.log('✅ Redis Publisher connected');
+        });
+        pubClient.on('reconnecting', () => {
+            console.log('🔄 Redis Publisher reconnecting...');
+        });
+        // Error handling for subscriber
+        subClient.on('error', (err) => {
+            console.error('❌ Redis Subscriber Error:', err);
+        });
+        subClient.on('connect', () => {
+            console.log('✅ Redis Subscriber connected');
+        });
+        subClient.on('reconnecting', () => {
+            console.log('🔄 Redis Subscriber reconnecting...');
+        });
+        // Connect both clients
+        await Promise.all([pubClient.connect(), subClient.connect()]);
+        // Create Socket.IO Redis adapter
+        redisAdapter = (0, redis_adapter_1.createAdapter)(pubClient, subClient, {
+            key: 'socket.io',
+            requestsTimeout: 5000
+        });
+        console.log('✅ Redis adapter created successfully');
+        return redisAdapter;
+    }
+    catch (error) {
+        console.error('❌ Failed to create Redis adapter:', error);
+        throw error;
+    }
+};
+exports.createRedisAdapter = createRedisAdapter;
+// Function to get Redis adapter instance
+const getRedisAdapter = () => {
+    return redisAdapter;
+};
+exports.getRedisAdapter = getRedisAdapter;
+// Function to get Redis clients for direct operations
+const getRedisClients = () => {
+    return { pubClient, subClient };
+};
+exports.getRedisClients = getRedisClients;
+// Graceful shutdown for Redis connections
+const closeRedisConnections = async () => {
+    try {
+        console.log('🛑 Closing Redis connections...');
+        if (pubClient && pubClient.isOpen) {
+            try {
+                await pubClient.quit();
+                console.log('✅ Redis Publisher connection closed');
+            }
+            catch (error) {
+                console.error('❌ Error closing Redis Publisher connection:', error);
+            }
+        }
+        else if (pubClient) {
+            console.log('⚠️ Redis Publisher was already closed');
+        }
+        if (subClient && subClient.isOpen) {
+            try {
+                await subClient.quit();
+                console.log('✅ Redis Subscriber connection closed');
+            }
+            catch (error) {
+                console.error('❌ Error closing Redis Subscriber connection:', error);
+            }
+        }
+        else if (subClient) {
+            console.log('⚠️ Redis Subscriber was already closed');
+        }
+    }
+    catch (error) {
+        console.error('❌ Error closing Redis connections:', error);
+    }
+};
+exports.closeRedisConnections = closeRedisConnections;

package/dist/lib/db/couchbaseClient.d.ts

@@ -0,0 +1,4 @@
+import { Collection } from 'couchbase';
+export declare function connectToCouchbase(): Promise<void>;
+export declare function queryData(query: string): Promise<any[]>;
+export declare function getCouchbaseUsersCollection(): Collection;

package/dist/lib/db/couchbaseClient.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectToCouchbase = connectToCouchbase;
+exports.queryData = queryData;
+exports.getCouchbaseUsersCollection = getCouchbaseUsersCollection;
+const couchbase_1 = require("couchbase");
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+let cluster;
+let bucket;
+let dataCollection;
+async function connectToCouchbase() {
+    try {
+        // Kết nối với Couchbase Cluster
+        cluster = await couchbase_1.Cluster.connect(`couchbase://${process.env.COUCHBASE_URL || '165.22.240.52'}`, {
+            username: process.env.COUCHBASE_USERNAME || 'nhat.huy.7996@gmail.com',
+            password: process.env.COUCHBASE_PASSWORD || 'oc3qKtHXELXL',
+        });
+        // Lấy bucket từ cluster
+        bucket = cluster.bucket(process.env.COUCHBASE_BUCKET || 'buildAnArmy');
+        //Get collection 
+        dataCollection = bucket.collection('users');
+        console.log('✅ Connected to Couchbase');
+    }
+    catch (err) {
+        console.error('❌ Failed to connect to Couchbase:', err);
+    }
+}
+/*
+* query Data from couchbase
+* @param query: string
+* @returns array of rows
+*/
+async function queryData(query) {
+    try {
+        const result = await cluster.query(query);
+        return result.rows; // Return array of rows
+    }
+    catch (err) {
+        console.error('Error executing query:', err);
+        throw new Error('Failed to fetch top users');
+    }
+}
+function getCouchbaseUsersCollection() {
+    if (!dataCollection) {
+        throw new Error('Couchbase is not connected. Call connectToCouchbase first.');
+    }
+    return dataCollection;
+}

package/dist/lib/db/lowdbClient.d.ts

@@ -0,0 +1,5 @@
+import { Low } from 'lowdb';
+interface Data {
+}
+export declare const db: Low<Data>;
+export {};

package/dist/lib/db/lowdbClient.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.db = void 0;
+const lowdb_1 = require("lowdb");
+const node_1 = require("lowdb/node");
+// File lưu dữ liệu
+const adapter = new node_1.JSONFile("db.json");
+exports.db = new lowdb_1.Low(adapter, { users: [] });

package/dist/lib/decorators/autoRouter.d.ts

@@ -0,0 +1,7 @@
+import 'reflect-metadata';
+import { Express } from 'express';
+export declare function RouterController(basePath?: string): ClassDecorator;
+export declare function Get(path: string): MethodDecorator;
+export declare function Post(path: string): MethodDecorator;
+export declare function Authen(): MethodDecorator & ClassDecorator;
+export declare function registerRoutes(app: Express, authMiddleware: any, ...controllers: any[]): void;

package/dist/lib/decorators/autoRouter.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterController = RouterController;
+exports.Get = Get;
+exports.Post = Post;
+exports.Authen = Authen;
+exports.registerRoutes = registerRoutes;
+require("reflect-metadata");
+const express_1 = require("express");
+const ROUTER_META = Symbol('router');
+const ROUTES_META = Symbol('routes');
+const AUTHEN_META = Symbol('authen');
+function RouterController(basePath = '') {
+    return (target) => {
+        Reflect.defineMetadata(ROUTER_META, basePath, target);
+    };
+}
+function Get(path) {
+    return (target, propertyKey) => {
+        const routes = Reflect.getMetadata(ROUTES_META, target.constructor) || [];
+        routes.push({ method: 'get', path, handler: propertyKey });
+        Reflect.defineMetadata(ROUTES_META, routes, target.constructor);
+    };
+}
+function Post(path) {
+    return (target, propertyKey) => {
+        const routes = Reflect.getMetadata(ROUTES_META, target.constructor) || [];
+        routes.push({ method: 'post', path, handler: propertyKey });
+        Reflect.defineMetadata(ROUTES_META, routes, target.constructor);
+    };
+}
+function Authen() {
+    return (target, propertyKey) => {
+        if (propertyKey) {
+            // Method
+            const authenMethods = Reflect.getMetadata(AUTHEN_META, target.constructor) || [];
+            authenMethods.push(propertyKey);
+            Reflect.defineMetadata(AUTHEN_META, authenMethods, target.constructor);
+        }
+        else {
+            // Class
+            Reflect.defineMetadata(AUTHEN_META, true, target);
+        }
+    };
+}
+function registerRoutes(app, authMiddleware, ...controllers) {
+    controllers.forEach(Controller => {
+        const basePath = Reflect.getMetadata(ROUTER_META, Controller) || '';
+        const routes = Reflect.getMetadata(ROUTES_META, Controller) || [];
+        const classAuthen = Reflect.getMetadata(AUTHEN_META, Controller);
+        const instance = new Controller();
+        const router = (0, express_1.Router)();
+        routes.forEach((route) => {
+            const handler = (req, res, next) => {
+                Promise.resolve(instance[route.handler](req, res, next)).catch(next);
+            };
+            const methodAuthenArr = Reflect.getMetadata(AUTHEN_META, Controller) || [];
+            const methodAuthen = Array.isArray(methodAuthenArr) && methodAuthenArr.includes(route.handler);
+            const routeMethod = route.method;
+            if (classAuthen || methodAuthen) {
+                router[routeMethod](route.path, authMiddleware, handler);
+            }
+            else {
+                router[routeMethod](route.path, handler);
+            }
+        });
+        app.use(basePath, router);
+    });
+}

package/dist/lib/decorators/initServer.d.ts

@@ -0,0 +1,19 @@
+import { Express } from 'express';
+import { Server as HTTPServer } from 'http';
+import { Server as SocketIOServer } from 'socket.io';
+export interface InitOptions {
+    port: number;
+    apiControllers?: any[];
+    socketServices?: any[];
+    authAPIMiddleware?: any;
+    onReady?: (app: Express, io: SocketIOServer, httpServer: HTTPServer) => void;
+    publicPath?: string;
+    expressConfig?: (app: Express) => void;
+    socketConfig?: (io: SocketIOServer) => void;
+    createRedisAdapter?: () => Promise<any>;
+}
+export declare function initServer(options: InitOptions): Promise<{
+    app: import("express-serve-static-core").Express;
+    io: SocketIOServer<import("socket.io").DefaultEventsMap, import("socket.io").DefaultEventsMap, import("socket.io").DefaultEventsMap, any>;
+    httpServer: HTTPServer;
+}>;

package/dist/lib/decorators/initServer.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initServer = initServer;
+const express_1 = __importDefault(require("express"));
+const http_1 = require("http");
+const socket_io_1 = require("socket.io");
+const autoRouter_1 = require("./autoRouter");
+const socketDecorators_1 = require("./socketDecorators");
+async function initServer(options) {
+    const app = (0, express_1.default)();
+    const httpServer = (0, http_1.createServer)(app);
+    const io = new socket_io_1.Server(httpServer, {
+        cors: {
+            origin: '*',
+            methods: ['GET', 'POST']
+        },
+        transports: ['websocket', 'polling'],
+        allowUpgrades: true,
+        connectTimeout: 45000,
+        pingTimeout: 60000,
+        pingInterval: 25000,
+        cookie: {
+            name: 'io',
+            httpOnly: true,
+            secure: true,
+            sameSite: 'none',
+            maxAge: 24 * 60 * 60 * 1000
+        },
+        connectionStateRecovery: {
+            maxDisconnectionDuration: 2 * 60 * 1000,
+            skipMiddlewares: true,
+        }
+    });
+    // Redis adapter support
+    if (options.createRedisAdapter) {
+        try {
+            const redisAdapter = await options.createRedisAdapter();
+            if (redisAdapter) {
+                io.adapter(redisAdapter);
+                console.log('✅ Socket.IO Redis adapter configured');
+            }
+        }
+        catch (err) {
+            console.warn('⚠️ Redis adapter failed to initialize, using default adapter:', err);
+        }
+    }
+    // Express config
+    app.use(express_1.default.json());
+    app.use((req, res, next) => {
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization');
+        res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.header('Access-Control-Allow-Credentials', 'true');
+        next();
+    });
+    if (options.publicPath) {
+        app.use(express_1.default.static(options.publicPath));
+    }
+    if (options.expressConfig) {
+        options.expressConfig(app);
+    }
+    // Register API controllers
+    if (options.apiControllers && options.apiControllers.length > 0) {
+        (0, autoRouter_1.registerRoutes)(app, options.authAPIMiddleware, ...options.apiControllers);
+    }
+    // Register socket services
+    if (options.socketServices && options.socketServices.length > 0) {
+        (0, socketDecorators_1.registerSocketServices)(io, ...options.socketServices);
+    }
+    if (options.socketConfig) {
+        options.socketConfig(io);
+    }
+    // Error handling
+    app.use((err, req, res, next) => {
+        console.error('Error:', err);
+        res.status(500).json({ error: 'Something went wrong!', details: err.message });
+    });
+    httpServer.listen(options.port, () => {
+        console.log(`Server is running on http://localhost:${options.port}`);
+        if (options.onReady)
+            options.onReady(app, io, httpServer);
+    });
+    return { app, io, httpServer };
+}

package/dist/lib/decorators/socketDecorators.d.ts

@@ -0,0 +1,8 @@
+import 'reflect-metadata';
+import { Server } from 'socket.io';
+export declare function AuthenSocket(): MethodDecorator & ClassDecorator;
+export declare function SocketService(): ClassDecorator;
+export declare function OnEvent(event: string): MethodDecorator;
+export declare function OnDisconnect(): MethodDecorator;
+export declare function OnError(): MethodDecorator;
+export declare function registerSocketServices(io: Server, ...serviceClasses: any[]): void;

package/dist/lib/decorators/socketDecorators.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthenSocket = AuthenSocket;
+exports.SocketService = SocketService;
+exports.OnEvent = OnEvent;
+exports.OnDisconnect = OnDisconnect;
+exports.OnError = OnError;
+exports.registerSocketServices = registerSocketServices;
+require("reflect-metadata");
+const SOCKET_SERVICE_META = Symbol('socket_service');
+const SOCKET_EVENTS_META = Symbol('socket_events');
+const SOCKET_AUTHEN_META = Symbol('socket_authen');
+// Decorator cho xác thực socket
+function AuthenSocket() {
+    return (target, propertyKey) => {
+        if (propertyKey) {
+            // Method
+            const authenMethods = Reflect.getMetadata(SOCKET_AUTHEN_META, target.constructor) || [];
+            authenMethods.push(propertyKey);
+            Reflect.defineMetadata(SOCKET_AUTHEN_META, authenMethods, target.constructor);
+        }
+        else {
+            // Class
+            Reflect.defineMetadata(SOCKET_AUTHEN_META, true, target);
+        }
+    };
+}
+function SocketService() {
+    return (target) => {
+        Reflect.defineMetadata(SOCKET_SERVICE_META, true, target);
+    };
+}
+function OnEvent(event) {
+    return (target, propertyKey) => {
+        const events = Reflect.getMetadata(SOCKET_EVENTS_META, target.constructor) || [];
+        events.push({ type: 'event', event, handler: propertyKey });
+        Reflect.defineMetadata(SOCKET_EVENTS_META, events, target.constructor);
+    };
+}
+function OnDisconnect() {
+    return (target, propertyKey) => {
+        const events = Reflect.getMetadata(SOCKET_EVENTS_META, target.constructor) || [];
+        events.push({ type: 'disconnect', handler: propertyKey });
+        Reflect.defineMetadata(SOCKET_EVENTS_META, events, target.constructor);
+    };
+}
+function OnError() {
+    return (target, propertyKey) => {
+        const events = Reflect.getMetadata(SOCKET_EVENTS_META, target.constructor) || [];
+        events.push({ type: 'error', handler: propertyKey });
+        Reflect.defineMetadata(SOCKET_EVENTS_META, events, target.constructor);
+    };
+}
+function registerSocketServices(io, ...serviceClasses) {
+    // Import middleware xác thực socket
+    const { authSocketToken } = require('../middleware/auth');
+    io.on('connection', (socket) => {
+        serviceClasses.forEach(ServiceClass => {
+            if (!Reflect.getMetadata(SOCKET_SERVICE_META, ServiceClass))
+                return;
+            // Nếu class nhận io ở constructor thì truyền vào
+            let instance;
+            try {
+                instance = new ServiceClass(io);
+            }
+            catch (_a) {
+                instance = new ServiceClass();
+            }
+            const events = Reflect.getMetadata(SOCKET_EVENTS_META, ServiceClass) || [];
+            const classAuthen = Reflect.getMetadata(SOCKET_AUTHEN_META, ServiceClass);
+            const methodAuthenArr = Reflect.getMetadata(SOCKET_AUTHEN_META, ServiceClass) || [];
+            events.forEach((evt) => {
+                const methodAuthen = Array.isArray(methodAuthenArr) && methodAuthenArr.includes(evt.handler);
+                const needAuth = classAuthen || methodAuthen;
+                const handler = (...args) => {
+                    Promise.resolve(instance[evt.handler](socket, ...args)).catch(console.error);
+                };
+                if (evt.type === 'event') {
+                    socket.on(evt.event, (...args) => {
+                        if (needAuth) {
+                            authSocketToken(socket, (err) => {
+                                if (err)
+                                    return socket.emit('server:error', err.message);
+                                handler(...args);
+                            });
+                        }
+                        else {
+                            handler(...args);
+                        }
+                    });
+                }
+                else if (evt.type === 'disconnect') {
+                    socket.on('disconnect', (...args) => handler(...args));
+                }
+                else if (evt.type === 'error') {
+                    socket.on('error', (...args) => handler(...args));
+                }
+            });
+        });
+    });
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,13 @@
+export * from './decorators/autoRouter';
+export * from './decorators/socketDecorators';
+export * from './decorators/initServer';
+export * from './middleware/auth';
+export * from './db/couchbaseClient';
+export * from './db/lowdbClient';
+export * from './config/redis';
+export * from '../utils/collisionDetector';
+export * from './utils/discordConnector';
+export * from './utils/teleConnector';
+export * from './utils/utils';
+export * from './types';
+export * from '../types/map';

package/dist/lib/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Decorators
+__exportStar(require("./decorators/autoRouter"), exports);
+__exportStar(require("./decorators/socketDecorators"), exports);
+__exportStar(require("./decorators/initServer"), exports);
+// Middleware
+__exportStar(require("./middleware/auth"), exports);
+// DB
+__exportStar(require("./db/couchbaseClient"), exports);
+__exportStar(require("./db/lowdbClient"), exports);
+// Redis
+__exportStar(require("./config/redis"), exports);
+// Utils
+__exportStar(require("../utils/collisionDetector"), exports);
+__exportStar(require("./utils/discordConnector"), exports);
+__exportStar(require("./utils/teleConnector"), exports);
+__exportStar(require("./utils/utils"), exports);
+// Types
+__exportStar(require("./types"), exports);
+__exportStar(require("../types/map"), exports);

package/dist/lib/middleware/auth.d.ts

@@ -0,0 +1,4 @@
+import { Response, NextFunction } from 'express';
+import { AuthenticatedRequest, AuthenticatedSocket } from '../types';
+export declare const authAPIToken: (req: AuthenticatedRequest, res: Response, next: NextFunction) => void | Response<any, Record<string, any>>;
+export declare const authSocketToken: (socket: AuthenticatedSocket, next: (err?: Error) => void) => void;

package/dist/lib/middleware/auth.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authSocketToken = exports.authAPIToken = void 0;
+const utils_1 = require("../utils/utils");
+const authAPIToken = (req, res, next) => {
+    // Skip authentication for OPTIONS requests (CORS preflight)
+    if (req.method === 'OPTIONS') {
+        console.log('🔄 Skipping auth for OPTIONS request (CORS preflight)');
+        return next();
+    }
+    console.log('🔍 Request method:', req.method);
+    console.log('🔍 Request URL:', req.url);
+    const auth = req.headers.authorization; // "Bearer <token>" 
+    const token = (auth === null || auth === void 0 ? void 0 : auth.startsWith("Bearer ")) ? auth.slice(7) : undefined;
+    console.log('🔑 API authentication token:', token);
+    if (!token) {
+        return res.status(401).json({
+            success: false,
+            message: 'No token provided'
+        });
+    }
+    try {
+        const decoded = utils_1.utils.tokenDecode(token);
+        req.userId = decoded.userId;
+        console.log('✅ API authenticated successfully for walletId:', decoded.walletId);
+        next();
+    }
+    catch (error) {
+        console.error(error);
+        return res.status(403).json({
+            success: false,
+            message: error
+        });
+    }
+};
+exports.authAPIToken = authAPIToken;
+const authSocketToken = (socket, next) => {
+    console.log('🔐 Socket authentication middleware triggered for socket:', socket.id);
+    try {
+        var token = socket.handshake.auth.token;
+        console.log(`🔑 Socket authentication token: ${token ? 'Present' : 'Missing'}`);
+        // Temporarily allow connections without token for debugging
+        if (!token) {
+            console.log('⚠️ No token provided, but allowing connection for debugging');
+            token = socket.handshake.query.token;
+        }
+        const decoded = utils_1.utils.tokenDecode(token);
+        console.log(decoded);
+        socket.userId = decoded.userId;
+        next();
+    }
+    catch (error) {
+        console.error('❌ Socket authentication error!');
+    }
+};
+exports.authSocketToken = authSocketToken;

package/dist/lib/types/index.d.ts

@@ -0,0 +1,22 @@
+import { Socket } from 'socket.io';
+import { Request } from 'express';
+export interface ApiResponse {
+    success: boolean;
+    message: string;
+    data?: any;
+}
+export interface AuthenticatedSocket extends Socket {
+    userId?: string;
+}
+export interface AuthenticatedRequest extends Request {
+    userId?: string;
+}
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Vector2 {
+    x: number;
+    y: number;
+}

package/dist/lib/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/utils/utils.d.ts

@@ -0,0 +1,5 @@
+export declare const utils: {
+    getMinutesPassed: (startAt: string) => number;
+    tokenDecode(token: string): any;
+    tokenEncode(data: any): string;
+};

package/dist/lib/utils/utils.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utils = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+exports.utils = {
+    getMinutesPassed: function (startAt) {
+        const startDate = new Date(startAt);
+        const currentDate = new Date();
+        const diffInMilliseconds = currentDate.getTime() - startDate.getTime();
+        return Math.floor(diffInMilliseconds / (1000 * 60)); // Chuyển đổi từ milliseconds sang phút
+    },
+    tokenDecode(token) {
+        const secret = process.env.JWT_SECRET || 'your-secret-key';
+        console.log('🔍 JWT Secret status:', process.env.JWT_SECRET ? 'Using environment JWT_SECRET' : 'Using default secret');
+        try {
+            const decoded = jsonwebtoken_1.default.verify(token, secret);
+            return decoded;
+        }
+        catch (error) {
+            console.error('❌ JWT verification failed!');
+            console.error('🔍 Token preview:', token.substring(0, 50) + '...');
+            throw error;
+        }
+    },
+    tokenEncode(data) {
+        const secret = process.env.JWT_SECRET || 'your-secret-key';
+        console.log('🔍 Creating JWT with secret:', process.env.JWT_SECRET ? 'Using environment JWT_SECRET' : 'Using default secret');
+        const token = jsonwebtoken_1.default.sign(data, secret, { expiresIn: '7d' });
+        console.log('✅ JWT token created successfully');
+        console.log('🔍 Token:', token);
+        return token;
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-game-decorators",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Express & Socket.IO decorators for auto routing and event handling. using for backend game development.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,7 +28,8 @@
     "redis": "^4.6.7",
     "@socket.io/redis-adapter": "^8.2.0",
     "lowdb": "^6.0.1",
-    "couchbase": "^4.2.5"
+    "couchbase": "^4.2.5",
+    "jsonwebtoken": "^9.0.2"
   },
   "devDependencies": {
     "typescript": "^5.0.0"