@enfin/chat-server 1.2.0

package/dist/gateways/chat.gateway.js

@@ -0,0 +1,439 @@
+"use strict";
+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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var ChatGateway_1;
+var _a, _b, _c, _d;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatGateway = void 0;
+const websockets_1 = require("@nestjs/websockets");
+const socket_io_1 = require("socket.io");
+const common_1 = require("@nestjs/common");
+const message_service_1 = require("../services/message.service");
+const room_service_1 = require("../services/room.service");
+const presence_service_1 = require("../services/presence.service");
+const call_service_1 = require("../services/call.service");
+const apikey_service_1 = require("../services/apikey.service");
+const chat_shared_1 = require("../../../shared/dist/index.js");
+let ChatGateway = ChatGateway_1 = class ChatGateway {
+    constructor(messageService, roomService, presenceService, callService, apiKeyService) {
+        this.messageService = messageService;
+        this.roomService = roomService;
+        this.presenceService = presenceService;
+        this.callService = callService;
+        this.apiKeyService = apiKeyService;
+        this.logger = new common_1.Logger(ChatGateway_1.name);
+        this.connectedUsers = new Map();
+    }
+    afterInit(server) {
+        this.logger.log('========================================');
+        this.logger.log('[GATEWAY] WebSocket Gateway initialized on namespace /chat');
+        this.logger.log('========================================');
+    }
+    async handleConnection(client) {
+        const auth = client.handshake.auth;
+        console.log('========================================');
+        console.log('[GATEWAY] handleConnection — socket.id =', client.id);
+        console.log('[GATEWAY] handshake.auth =', JSON.stringify(auth));
+        console.log('========================================');
+        const { apiKey, userId, userName } = auth;
+        if (!apiKey) {
+            console.log('[GATEWAY] Missing apiKey in handshake — disconnecting client', client.id);
+            client.emit('error', { code: 'MISSING_API_KEY', message: 'apiKey is required in handshake auth' });
+            client.disconnect();
+            return;
+        }
+        if (!userId || !userName) {
+            console.log('[GATEWAY] Missing userId/userName — disconnecting client', client.id);
+            client.emit('error', { code: 'MISSING_USER', message: 'userId and userName are required' });
+            client.disconnect();
+            return;
+        }
+        const validation = await this.apiKeyService.validateKey(apiKey);
+        if (!validation.valid) {
+            console.log(`[GATEWAY] Invalid apiKey=${apiKey.slice(0, 12)}... reason=${validation.error} — disconnecting`);
+            client.emit('error', { code: 'INVALID_API_KEY', message: validation.error || 'Invalid apiKey' });
+            client.disconnect();
+            return;
+        }
+        const tenantId = validation.tenantId;
+        const mode = validation.mode;
+        this.connectedUsers.set(client.id, { userId, userName, tenantId, apiKey, mode });
+        await this.presenceService.setOnline(tenantId, userId);
+        // Broadcast presence change to all other connected clients
+        this.server.emit('presence:changed', { userId, status: 'online' });
+        console.log(`[GATEWAY] User connected: userId=${userId} userName=${userName} tenantId=${tenantId} mode=${mode} socketId=${client.id}`);
+        console.log(`[GATEWAY] Total connected users:`, this.connectedUsers.size);
+    }
+    async handleDisconnect(client) {
+        const user = this.connectedUsers.get(client.id);
+        if (user) {
+            // Check if user has other active connections
+            const otherConnections = Array.from(this.connectedUsers.values()).filter((u, idx) => u.userId === user.userId && idx !== this._keyIndex(client.id));
+            // Only mark offline if no other connections exist for this user
+            if (otherConnections.length === 0) {
+                await this.presenceService.setOffline(user.tenantId, user.userId);
+                // Broadcast presence change to all other connected clients
+                this.server.emit('presence:changed', { userId: user.userId, status: 'offline' });
+                // End any ringing/active calls this user was in. Refresh, network loss,
+                // or browser crash otherwise leaves the call record stuck and blocks
+                // subsequent call attempts.
+                try {
+                    const endedCalls = await this.callService.endCallsForUser(user.tenantId, user.userId, 'peer_disconnected');
+                    for (const call of endedCalls) {
+                        console.log(`[GATEWAY] Auto-ended call ${call._id} in room ${call.roomId} due to disconnect of userId=${user.userId}`);
+                        const updated = await this.callService.getCall(user.tenantId, call._id.toString());
+                        this.emitToRoom(call.roomId, 'call:ended', updated);
+                    }
+                }
+                catch (err) {
+                    console.log(`[GATEWAY] Failed to end calls on disconnect for user=${user.userId}:`, err?.message || err);
+                }
+            }
+            this.connectedUsers.delete(client.id);
+            console.log(`[GATEWAY] User disconnected: userId=${user.userId} socketId=${client.id}`);
+            console.log(`[GATEWAY] Total connected users remaining:`, this.connectedUsers.size);
+        }
+        else {
+            console.log(`[GATEWAY] Unknown socket disconnected: ${client.id}`);
+        }
+    }
+    _keyIndex(key) {
+        let i = 0;
+        for (const k of this.connectedUsers.keys()) {
+            if (k === key)
+                return i;
+            i++;
+        }
+        return -1;
+    }
+    async handleMessage(client, payload) {
+        const user = this.connectedUsers.get(client.id);
+        if (!user)
+            return;
+        console.log('Received message payload from user:', user.userId, payload);
+        console.log(`[GATEWAY] message:send — user=${user.userId} payload=${JSON.stringify(payload)}`);
+        this.logger.log(`Received message: user=${user.userId} payload=${JSON.stringify(payload)}`);
+        console.log('roomId :', payload?.roomId);
+        console.log('!payload :', !payload);
+        if (!payload || !payload.roomId) {
+            const stored = this.connectedUsers.get(client.id);
+            const fallbackRoom = stored?.activeRoomId;
+            if (fallbackRoom) {
+                payload = { ...(payload || {}), roomId: fallbackRoom };
+                this.logger.log(`Using fallback roomId=${fallbackRoom} for user=${user.userId}`);
+            }
+            else {
+                this.logger.warn(`Invalid message payload from user=${user.userId}: missing roomId`);
+                throw new websockets_1.WsException('roomId is required');
+            }
+        }
+        console.log('[GATEWAY] Calling messageService.createMessage with payload:', JSON.stringify(payload));
+        let message;
+        try {
+            message = await this.messageService.createMessage(user.tenantId, payload, user.userId, user.userName);
+        }
+        catch (err) {
+            console.log('[GATEWAY] ERROR in createMessage:', err?.message || err);
+            console.log('[GATEWAY] Stack:', err?.stack);
+            console.log('[GATEWAY] Validation errors:', JSON.stringify(err?.errors || {}));
+            throw err;
+        }
+        console.log('[GATEWAY] messageService.createMessage returned:');
+        console.log('[GATEWAY]   _id =', message?._id);
+        console.log('[GATEWAY]   roomId =', message?.roomId);
+        console.log('[GATEWAY]   senderId =', message?.senderId);
+        console.log('[GATEWAY]   content =', message?.content);
+        console.log('[GATEWAY]   toJSON =', JSON.stringify(message));
+        console.log('Gateway created message:', message?._id, 'for room:', payload.roomId);
+        // Get room members and emit to them
+        const room = await this.roomService.getRoom(user.tenantId, payload.roomId);
+        const roomChannel = `room:${payload.roomId}`;
+        console.log(`[GATEWAY] Room channel =`, roomChannel);
+        // Auto-join all connected sockets belonging to room members to the room channel
+        // This ensures every member receives messages even if they haven't explicitly joined
+        if (room && Array.isArray(room.members)) {
+            const memberIds = new Set(room.members);
+            for (const [socketId, socketUser] of this.connectedUsers.entries()) {
+                if (memberIds.has(socketUser.userId)) {
+                    const sock = this.server.sockets.get(socketId);
+                    if (sock) {
+                        try {
+                            await sock.join(roomChannel);
+                        }
+                        catch (e) {
+                            console.log('[GATEWAY] Auto-join error for socket', socketId, e?.message);
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            // No room found or no members — at least ensure sender is in channel
+            client.join(roomChannel);
+        }
+        const socketsInRoom = await this.server.in(roomChannel).fetchSockets();
+        console.log(`[GATEWAY] Sockets in room ${roomChannel}: ${socketsInRoom.length} sockets`);
+        console.log(`[GATEWAY] Socket IDs:`, socketsInRoom.map(s => s.id));
+        // Broadcast to all sockets in the room
+        console.log(`[GATEWAY] -> emitToRoom(${payload.roomId}, 'message:new', message)`);
+        this.emitToRoom(payload.roomId, 'message:new', message);
+        return message;
+    }
+    async handleTyping(client, payload) {
+        const user = this.connectedUsers.get(client.id);
+        if (!user)
+            return;
+        const p = payload;
+        const isTyping = !!(p.typing || p.content);
+        if (isTyping) {
+            await this.presenceService.setTyping(user.tenantId, user.userId, p.roomId);
+        }
+        else {
+            await this.presenceService.stopTyping(user.tenantId, user.userId, p.roomId);
+        }
+        // Broadcast typing to room members
+        this.emitToRoomExcept(p.roomId, 'message:typing', { userId: user.userId, userName: user.userName, roomId: p.roomId, typing: isTyping }, user.userId);
+    }
+    async handleRoomSelect(client, payload) {
+        console.log('========================================');
+        console.log('[GATEWAY] room:select received');
+        console.log('[GATEWAY] client.id =', client.id);
+        console.log('[GATEWAY] raw payload =', JSON.stringify(payload));
+        console.log('========================================');
+        const user = this.connectedUsers.get(client.id);
+        if (!user) {
+            console.log('[GATEWAY] room:select — unknown client, returning');
+            return;
+        }
+        const { roomId } = payload || {};
+        if (!roomId) {
+            console.log('[GATEWAY] room:select — missing roomId, returning');
+            return;
+        }
+        console.log(`[GATEWAY] room:select — user=${user.userId} joining room:${roomId}`);
+        // Track active room on connected user and join socket to room channel
+        const existing = this.connectedUsers.get(client.id) || { userId: user.userId, userName: user.userName, tenantId: user.tenantId };
+        this.connectedUsers.set(client.id, { ...existing, activeRoomId: roomId });
+        try {
+            client.join(`room:${roomId}`);
+            this.logger.log(`Socket ${client.id} joined room:${roomId} for user=${user.userId}`);
+        }
+        catch (err) {
+            this.logger.warn(`Failed to join socket to room:${roomId}: ${err}`);
+        }
+        return { ok: true };
+    }
+    async handleRoomJoin(client, payload) {
+        const user = this.connectedUsers.get(client.id);
+        if (!user) {
+            return { ok: false, error: 'unknown client' };
+        }
+        const { roomId } = payload || {};
+        if (!roomId) {
+            return { ok: false, error: 'roomId required' };
+        }
+        try {
+            // Verify the user is a member of this room
+            const isMember = await this.roomService.isMember(user.tenantId, roomId, user.userId);
+            if (!isMember) {
+                console.log(`[GATEWAY] room:join — user=${user.userId} is NOT a member of room=${roomId}`);
+                return { ok: false, error: 'not a member' };
+            }
+            client.join(`room:${roomId}`);
+            console.log(`[GATEWAY] room:join — user=${user.userId} joined room:${roomId}`);
+            return { ok: true, roomId };
+        }
+        catch (err) {
+            console.log(`[GATEWAY] room:join — error:`, err?.message || err);
+            return { ok: false, error: err?.message || 'join failed' };
+        }
+    }
+    async handlePresenceUpdate(client, payload) {
+        const user = this.connectedUsers.get(client.id);
+        if (!user)
+            return;
+        await this.presenceService.setStatus(user.tenantId, user.userId, payload);
+        // Broadcast presence to all connected users
+        this.server.emit('presence:changed', {
+            userId: user.userId,
+            status: payload.status,
+        });
+    }
+    async handleCallInitiate(client, payload) {
+        const user = this.connectedUsers.get(client.id);
+        if (!user)
+            return;
+        const call = await this.callService.initiateCall(user.tenantId, payload.roomId, user.userId, payload.participantId);
+        // Notify the participant
+        this.emitToUser(payload.participantId, 'call:incoming', call);
+        return call;
+    }
+    async handleCallAccept(client, payload) {
+        const user = this.connectedUsers.get(client.id);
+        if (!user)
+            return;
+        const call = await this.callService.acceptCall(user.tenantId, payload.callId, user.userId);
+        // Notify both parties
+        this.emitToRoom(call.roomId, 'call:accepted', call);
+        return call;
+    }
+    async handleCallReject(client, payload) {
+        const user = this.connectedUsers.get(client.id);
+        if (!user)
+            return;
+        const call = await this.callService.rejectCall(user.tenantId, payload.callId, user.userId);
+        this.emitToRoom(call.roomId, 'call:rejected', call);
+        return call;
+    }
+    async handleCallEnd(client, payload) {
+        const user = this.connectedUsers.get(client.id);
+        if (!user)
+            return;
+        const call = await this.callService.endCall(user.tenantId, payload.callId);
+        this.emitToRoom(call.roomId, 'call:ended', call);
+        return call;
+    }
+    async handleCallSignal(client, payload) {
+        const user = this.connectedUsers.get(client.id);
+        if (!user)
+            return;
+        const call = await this.callService.getActiveCall(user.tenantId, payload.roomId);
+        console.log();
+        if (!call)
+            return;
+        const targetId = call.initiatorId === user.userId ? call.participantId : call.initiatorId;
+        this.emitToUser(targetId, 'call:signal', payload);
+    }
+    emitToRoom(roomId, event, data, excludeUserId) {
+        console.log(`[GATEWAY] emitToRoom(roomId=${roomId}, event='${event}', excludeUserId=${excludeUserId})`);
+        this.server.to(`room:${roomId}`).emit(event, data);
+    }
+    emitToRoomExcept(roomId, event, data, excludeUserId) {
+        console.log(`[GATEWAY] emitToRoomExcept(roomId=${roomId}, event='${event}', excludeUserId=${excludeUserId})`);
+        const roomChannel = `room:${roomId}`;
+        for (const [socketId, user] of this.connectedUsers.entries()) {
+            if (user.userId === excludeUserId)
+                continue;
+            const sock = this.server.sockets.get(socketId);
+            if (sock && sock.rooms?.has(roomChannel)) {
+                sock.emit(event, data);
+            }
+        }
+    }
+    emitToUser(userId, event, data) {
+        console.log(`[GATEWAY] emitToUser(userId=${userId}, event='${event}')`);
+        for (const [socketId, user] of this.connectedUsers.entries()) {
+            if (user.userId === userId) {
+                this.server.to(socketId).emit(event, data);
+            }
+        }
+    }
+};
+exports.ChatGateway = ChatGateway;
+__decorate([
+    (0, websockets_1.WebSocketServer)(),
+    __metadata("design:type", socket_io_1.Server)
+], ChatGateway.prototype, "server", void 0);
+__decorate([
+    (0, websockets_1.SubscribeMessage)('message:send'),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __param(1, (0, websockets_1.MessageBody)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [socket_io_1.Socket, typeof (_a = typeof chat_shared_1.SendMessagePayload !== "undefined" && chat_shared_1.SendMessagePayload) === "function" ? _a : Object]),
+    __metadata("design:returntype", Promise)
+], ChatGateway.prototype, "handleMessage", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)('message:typing'),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __param(1, (0, websockets_1.MessageBody)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [socket_io_1.Socket, typeof (_b = typeof chat_shared_1.TypingPayload !== "undefined" && chat_shared_1.TypingPayload) === "function" ? _b : Object]),
+    __metadata("design:returntype", Promise)
+], ChatGateway.prototype, "handleTyping", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)('room:select'),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __param(1, (0, websockets_1.MessageBody)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [socket_io_1.Socket, Object]),
+    __metadata("design:returntype", Promise)
+], ChatGateway.prototype, "handleRoomSelect", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)('room:join'),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __param(1, (0, websockets_1.MessageBody)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [socket_io_1.Socket, Object]),
+    __metadata("design:returntype", Promise)
+], ChatGateway.prototype, "handleRoomJoin", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)('presence:update'),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __param(1, (0, websockets_1.MessageBody)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [socket_io_1.Socket, typeof (_c = typeof chat_shared_1.PresencePayload !== "undefined" && chat_shared_1.PresencePayload) === "function" ? _c : Object]),
+    __metadata("design:returntype", Promise)
+], ChatGateway.prototype, "handlePresenceUpdate", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)('call:initiate'),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __param(1, (0, websockets_1.MessageBody)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [socket_io_1.Socket, Object]),
+    __metadata("design:returntype", Promise)
+], ChatGateway.prototype, "handleCallInitiate", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)('call:accept'),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __param(1, (0, websockets_1.MessageBody)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [socket_io_1.Socket, Object]),
+    __metadata("design:returntype", Promise)
+], ChatGateway.prototype, "handleCallAccept", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)('call:reject'),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __param(1, (0, websockets_1.MessageBody)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [socket_io_1.Socket, Object]),
+    __metadata("design:returntype", Promise)
+], ChatGateway.prototype, "handleCallReject", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)('call:end'),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __param(1, (0, websockets_1.MessageBody)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [socket_io_1.Socket, Object]),
+    __metadata("design:returntype", Promise)
+], ChatGateway.prototype, "handleCallEnd", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)('call:signal'),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __param(1, (0, websockets_1.MessageBody)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [socket_io_1.Socket, typeof (_d = typeof chat_shared_1.CallSignalingPayload !== "undefined" && chat_shared_1.CallSignalingPayload) === "function" ? _d : Object]),
+    __metadata("design:returntype", Promise)
+], ChatGateway.prototype, "handleCallSignal", null);
+exports.ChatGateway = ChatGateway = ChatGateway_1 = __decorate([
+    (0, websockets_1.WebSocketGateway)({
+        cors: {
+            origin: '*',
+        },
+        namespace: '/chat',
+    }),
+    __metadata("design:paramtypes", [message_service_1.MessageService,
+        room_service_1.RoomService,
+        presence_service_1.PresenceService,
+        call_service_1.CallService,
+        apikey_service_1.ApiKeyService])
+], ChatGateway);

package/dist/index.js

@@ -0,0 +1,26 @@
+"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 });
+exports.ChatGateway = void 0;
+__exportStar(require("./chat.module"), exports);
+__exportStar(require("./chat-mongoose.module"), exports);
+__exportStar(require("./schemas"), exports);
+__exportStar(require("./services/message.service"), exports);
+__exportStar(require("./services/room.service"), exports);
+__exportStar(require("./services/presence.service"), exports);
+__exportStar(require("./services/call.service"), exports);
+var chat_gateway_1 = require("./gateways/chat.gateway");
+Object.defineProperty(exports, "ChatGateway", { enumerable: true, get: function () { return chat_gateway_1.ChatGateway; } });

package/dist/interfaces/index.js

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

package/dist/main.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Standalone entry point — NOT needed when ChatModule is mounted in developer's existing NestJS app.
+ *
+ * For standalone dev testing only:
+ *   npm run start
+ * Or:
+ *   PORT=3002 node dist/main.js
+ *
+ * For production / developer install — they mount ChatModule.forRoot in their own AppModule.
+ */
+require("reflect-metadata");
+const core_1 = require("@nestjs/core");
+const common_1 = require("@nestjs/common");
+const chat_module_1 = require("./chat.module");
+async function bootstrap() {
+    const app = await core_1.NestFactory.create(chat_module_1.ChatModule.forRoot({
+        apiKey: process.env.CHAT_API_KEY || 'chat_dev_key',
+        mongoUri: process.env.MONGO_URI,
+        mode: process.env.CHAT_MODE || 'managed',
+        version: process.env.CHAT_VERSION || '1.0.0',
+    }));
+    app.enableCors({
+        origin: '*',
+        credentials: true,
+    });
+    app.useGlobalPipes(new common_1.ValidationPipe({
+        whitelist: true,
+        transform: true,
+    }));
+    app.setGlobalPrefix('api');
+    const port = process.env.PORT || 3002;
+    await app.listen(port);
+    console.log(`ChatModule (standalone) running on port ${port}`);
+    console.log(`Use ChatModule.forRoot in your own NestJS app instead of running this standalone.`);
+}
+bootstrap();

package/dist/schemas/apikey.schema.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiKey = exports.ApiKeySchema = void 0;
+const mongoose_1 = require("mongoose");
+exports.ApiKeySchema = new mongoose_1.Schema({
+    apiKey: { type: String, required: true, unique: true, index: true },
+    tenantId: { type: String, required: true, index: true },
+    mode: {
+        type: String,
+        enum: ['managed', 'external-db'],
+        required: true,
+        default: 'managed',
+    },
+    database: { type: String },
+    version: { type: String, required: true, default: '1.0.0' },
+    status: {
+        type: String,
+        enum: ['active', 'revoked', 'expired'],
+        required: true,
+        default: 'active',
+    },
+}, {
+    timestamps: true,
+    toJSON: {
+        virtuals: true,
+        transform: function (doc, ret) {
+            ret.id = ret._id;
+            delete ret.__v;
+            return ret;
+        },
+    },
+});
+exports.ApiKey = (0, mongoose_1.model)('ApiKey', exports.ApiKeySchema);

package/dist/schemas/audiocall.schema.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AudioCall = exports.AudioCallSchema = void 0;
+const mongoose_1 = require("mongoose");
+exports.AudioCallSchema = new mongoose_1.Schema({
+    tenantId: { type: String, required: true, index: true },
+    roomId: {
+        type: String,
+        required: true,
+        index: true
+    },
+    initiatorId: {
+        type: String,
+        required: true,
+        index: true
+    },
+    participantId: {
+        type: String,
+        required: true,
+        index: true
+    },
+    status: {
+        type: String,
+        enum: ['ringing', 'active', 'ended'],
+        default: 'ringing'
+    },
+    startedAt: { type: Date, default: Date.now },
+    endedAt: { type: Date },
+    duration: { type: Number },
+    endReason: { type: String }
+}, {
+    timestamps: false,
+    toJSON: {
+        virtuals: true,
+        transform: function (doc, ret) {
+            ret.id = ret._id;
+            delete ret.__v;
+            return ret;
+        }
+    }
+});
+// Index for finding active calls
+exports.AudioCallSchema.index({ tenantId: 1, status: 1 });
+exports.AudioCallSchema.index({ tenantId: 1, roomId: 1, status: 1 });
+// Indexes for the cross-call busy check (look up by initiatorId or participantId)
+exports.AudioCallSchema.index({ tenantId: 1, initiatorId: 1, status: 1 });
+exports.AudioCallSchema.index({ tenantId: 1, participantId: 1, status: 1 });
+// Export model after schema is declared
+exports.AudioCall = (0, mongoose_1.model)('AudioCall', exports.AudioCallSchema);

package/dist/schemas/index.js

@@ -0,0 +1,34 @@
+"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 });
+exports.schemas = void 0;
+__exportStar(require("./message.schema"), exports);
+__exportStar(require("./room.schema"), exports);
+__exportStar(require("./presence.schema"), exports);
+__exportStar(require("./audiocall.schema"), exports);
+__exportStar(require("./user.schema"), exports);
+const message_schema_1 = require("./message.schema");
+const room_schema_1 = require("./room.schema");
+const presence_schema_1 = require("./presence.schema");
+const audiocall_schema_1 = require("./audiocall.schema");
+const user_schema_1 = require("./user.schema");
+exports.schemas = [
+    { name: 'Message', schema: message_schema_1.MessageSchema },
+    { name: 'Room', schema: room_schema_1.RoomSchema },
+    { name: 'Presence', schema: presence_schema_1.PresenceSchema },
+    { name: 'AudioCall', schema: audiocall_schema_1.AudioCallSchema },
+    { name: 'User', schema: user_schema_1.UserSchema },
+];

package/dist/schemas/message.schema.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = exports.MessageSchema = void 0;
+const mongoose_1 = require("mongoose");
+const readReceiptSchema = new mongoose_1.Schema({
+    userId: { type: String, required: true },
+    readAt: { type: Date, required: true, default: Date.now }
+});
+exports.MessageSchema = new mongoose_1.Schema({
+    tenantId: { type: String, required: true, index: true },
+    roomId: {
+        type: String,
+        required: true,
+        index: true
+    },
+    senderId: {
+        type: String,
+        required: true,
+        index: true
+    },
+    senderName: { type: String, required: true },
+    senderAvatar: { type: String },
+    content: { type: String, required: true },
+    fileUrl: { type: String },
+    fileType: { type: String },
+    fileName: { type: String },
+    readBy: { type: [readReceiptSchema], default: [] }
+}, {
+    timestamps: true
+});
+exports.MessageSchema.index({ tenantId: 1, roomId: 1, createdAt: -1 });
+exports.MessageSchema.set('toJSON', {
+    virtuals: true,
+    transform: function (doc, ret) {
+        ret.id = ret._id;
+        delete ret.__v;
+    }
+});
+// Export model after schema declaration
+exports.Message = (0, mongoose_1.model)('Message', exports.MessageSchema);