@enfin/chat-server 1.2.0

package/dist/schemas/presence.schema.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresenceStatus = exports.PresenceSchema = void 0;
+const mongoose_1 = require("mongoose");
+exports.PresenceSchema = new mongoose_1.Schema({
+    tenantId: { type: String, required: true, index: true },
+    userId: {
+        type: String,
+        required: true,
+        index: true
+    },
+    status: {
+        type: String,
+        enum: ['online', 'offline', 'away'],
+        default: 'offline'
+    },
+    lastSeen: { type: Date, default: Date.now },
+    typingIn: [{ type: String }]
+}, {
+    timestamps: false
+});
+exports.PresenceSchema.index({ tenantId: 1, userId: 1 }, { unique: true });
+exports.PresenceStatus = (0, mongoose_1.model)('Presence', exports.PresenceSchema);

package/dist/schemas/room.schema.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Room = exports.RoomSchema = void 0;
+const mongoose_1 = require("mongoose");
+exports.RoomSchema = new mongoose_1.Schema({
+    tenantId: { type: String, required: true, index: true },
+    name: { type: String, required: true },
+    type: {
+        type: String,
+        enum: ['direct', 'group'],
+        required: true,
+        default: 'group'
+    },
+    members: [{
+            type: String,
+        }],
+    membersHash: { type: String },
+    createdBy: { type: String, required: true },
+    lastMessage: { type: mongoose_1.Schema.Types.ObjectId, ref: 'Message' },
+    lastActivity: { type: Date, default: Date.now },
+    avatar: { type: String }
+}, {
+    timestamps: true,
+    toJSON: {
+        virtuals: true,
+        transform: function (doc, ret) {
+            ret.id = ret._id;
+            delete ret.__v;
+            return ret;
+        }
+    }
+});
+// Indexes
+exports.RoomSchema.index({ tenantId: 1, members: 1 });
+exports.RoomSchema.index({ tenantId: 1, lastActivity: -1 });
+exports.RoomSchema.index({ tenantId: 1, name: 'text', description: 'text' });
+// Prevent duplicate direct rooms within the same tenant.
+// The members array is sorted at write time so the same pair always has the same key.
+exports.RoomSchema.index({ tenantId: 1, type: 1, membersHash: 1 }, { unique: true, partialFilterExpression: { type: 'direct' } });
+exports.Room = (0, mongoose_1.model)('Room', exports.RoomSchema);

package/dist/schemas/user.schema.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = exports.UserSchema = void 0;
+const mongoose_1 = require("mongoose");
+exports.UserSchema = new mongoose_1.Schema({
+    userId: { type: String, required: true, index: true },
+    tenantId: { type: String, required: true, index: true },
+    name: { type: String, required: true },
+    avatar: { type: String },
+}, {
+    timestamps: { createdAt: true, updatedAt: false }
+});
+exports.UserSchema.index({ tenantId: 1, userId: 1 }, { unique: true });
+exports.User = (0, mongoose_1.model)('User', exports.UserSchema);

package/dist/services/apikey.service.js

@@ -0,0 +1,120 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var ApiKeyService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiKeyService = void 0;
+const common_1 = require("@nestjs/common");
+const axios_1 = __importDefault(require("axios"));
+const chat_shared_1 = require("../../../shared/dist/index.js");
+const VALIDATION_CACHE_TTL_MS = 5 * 60 * 1000;
+const ADMIN_HTTP_TIMEOUT_MS = 5000;
+// Use string literal directly to avoid circular import with chat.module.ts.
+// The token MUST stay in sync with CHAT_MODULE_OPTIONS in chat.module.ts.
+const CHAT_MODULE_OPTIONS_TOKEN = 'CHAT_MODULE_OPTIONS';
+let ApiKeyService = ApiKeyService_1 = class ApiKeyService {
+    constructor(options) {
+        this.logger = new common_1.Logger(ApiKeyService_1.name);
+        this.cache = new Map();
+        this.moduleOptions = options;
+    }
+    resolveAdminUrl() {
+        const fromOptions = this.moduleOptions?.adminValidationUrl?.trim();
+        const fromEnv = process.env.ADMIN_API_VALIDATION_URL ||
+            process.env.API_VALIDATION_URL ||
+            process.env.VALIDATION_URL;
+        const raw = fromOptions || fromEnv;
+        if (!raw)
+            return undefined;
+        return raw.replace(/\/+$/, '');
+    }
+    async validateKey(apiKey, clientVersion) {
+        if (!apiKey) {
+            return {
+                valid: false,
+                apiKey: '',
+                mode: 'managed',
+                version: '1.0.0',
+                tenantId: '',
+                error: 'apiKey required',
+            };
+        }
+        const cached = this.cache.get(apiKey);
+        if (cached && cached.expiresAt > Date.now()) {
+            return cached.result;
+        }
+        const adminUrl = this.resolveAdminUrl();
+        if (!adminUrl) {
+            return {
+                valid: false,
+                apiKey,
+                mode: 'managed',
+                version: '1.0.0',
+                tenantId: '',
+                error: 'ADMIN_API_VALIDATION_URL not configured',
+            };
+        }
+        const validateUrl = `${adminUrl}/api/validation/validate`;
+        try {
+            const response = await axios_1.default.post(validateUrl, { apiKey, clientVersion: clientVersion || chat_shared_1.SDK_VERSION }, { timeout: ADMIN_HTTP_TIMEOUT_MS, headers: { 'Content-Type': 'application/json' } });
+            const data = response?.data;
+            if (!data || typeof data.valid !== 'boolean') {
+                this.logger.warn(`Admin validation returned unexpected payload for ${apiKey.slice(0, 12)}...`);
+                return {
+                    valid: false,
+                    apiKey,
+                    mode: 'managed',
+                    version: '1.0.0',
+                    tenantId: '',
+                    error: 'Invalid admin response',
+                };
+            }
+            const result = data;
+            if (result.valid) {
+                this.cache.set(apiKey, { result, expiresAt: Date.now() + VALIDATION_CACHE_TTL_MS });
+                this.logger.log(`[VALIDATION] admin -> valid tenantId=${result.tenantId} mode=${result.mode} database=${result.database || '-'}`);
+            }
+            else {
+                this.logger.log(`[VALIDATION] admin -> invalid apiKey=${apiKey.slice(0, 12)}... reason=${result.error || 'unknown'}`);
+            }
+            return result;
+        }
+        catch (err) {
+            const axiosErr = err;
+            const reason = axiosErr?.response?.status
+                ? `HTTP ${axiosErr.response.status}`
+                : axiosErr?.message || String(err);
+            this.logger.error(`Admin validation request failed (${reason})`);
+            return {
+                valid: false,
+                apiKey,
+                mode: 'managed',
+                version: '1.0.0',
+                tenantId: '',
+                error: `ApiKey registry unavailable: ${reason}`,
+            };
+        }
+    }
+    clearCache() {
+        this.cache.clear();
+    }
+};
+exports.ApiKeyService = ApiKeyService;
+exports.ApiKeyService = ApiKeyService = ApiKeyService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(CHAT_MODULE_OPTIONS_TOKEN)),
+    __metadata("design:paramtypes", [Object])
+], ApiKeyService);

package/dist/services/call.service.js

@@ -0,0 +1,145 @@
+"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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallService = void 0;
+const common_1 = require("@nestjs/common");
+const mongoose_1 = require("@nestjs/mongoose");
+const mongoose_2 = require("mongoose");
+const audiocall_schema_1 = require("../schemas/audiocall.schema");
+let CallService = class CallService {
+    constructor(callModel) {
+        this.callModel = callModel;
+    }
+    async initiateCall(tenantId, roomId, initiatorId, participantId) {
+        // Clean up stale "ringing" calls (orphans from prior failed calls).
+        // A "ringing" record older than 30s without being accepted is definitely stale.
+        const staleThreshold = new Date(Date.now() - 30 * 1000);
+        await this.callModel.updateMany({
+            tenantId,
+            roomId,
+            status: 'ringing',
+            startedAt: { $lt: staleThreshold },
+        }, { $set: { status: 'ended', endedAt: new Date(), endReason: 'stale' } });
+        const existingCall = await this.callModel.findOne({
+            tenantId,
+            roomId,
+            status: { $in: ['ringing', 'active'] },
+        });
+        if (existingCall)
+            throw new common_1.BadRequestException('A call is already in progress in this room');
+        // Block if either party is already on a call (in any room). We look up the
+        // audiocalls collection by matching initiatorId OR participantId against
+        // the caller/callee with status "ringing" or "active". If we find any
+        // ongoing call involving either user, the line is busy.
+        const busyCall = await this.callModel.findOne({
+            tenantId,
+            status: { $in: ['ringing', 'active'] },
+            $or: [
+                { initiatorId: participantId },
+                { participantId: participantId },
+                { initiatorId: initiatorId },
+                { participantId: initiatorId },
+            ],
+        });
+        if (busyCall) {
+            // If the busy call involves the callee, say the user is busy.
+            // If it involves the caller, say the caller is already on a call.
+            const isCalleeBusy = busyCall.initiatorId === participantId || busyCall.participantId === participantId;
+            if (isCalleeBusy) {
+                throw new common_1.BadRequestException('The user you are calling is busy on another call');
+            }
+            throw new common_1.BadRequestException('You are already on a call');
+        }
+        const call = new this.callModel({
+            tenantId,
+            roomId,
+            initiatorId,
+            participantId,
+            status: 'ringing',
+            startedAt: new Date(),
+        });
+        return call.save();
+    }
+    async acceptCall(tenantId, callId, userId) {
+        const call = await this.callModel.findOne({ _id: callId, tenantId });
+        if (!call)
+            throw new common_1.NotFoundException('Call not found');
+        if (call.participantId !== userId && call.initiatorId !== userId) {
+            throw new common_1.BadRequestException('You are not authorized to accept this call');
+        }
+        call.status = 'active';
+        return call.save();
+    }
+    async rejectCall(tenantId, callId, userId) {
+        const call = await this.callModel.findOne({ _id: callId, tenantId });
+        if (!call)
+            throw new common_1.NotFoundException('Call not found');
+        if (call.participantId !== userId && call.initiatorId !== userId) {
+            throw new common_1.BadRequestException('You are not authorized to reject this call');
+        }
+        call.status = 'ended';
+        call.endedAt = new Date();
+        return call.save();
+    }
+    async endCall(tenantId, callId) {
+        const call = await this.callModel.findOne({ _id: callId, tenantId });
+        if (!call)
+            throw new common_1.NotFoundException('Call not found');
+        call.status = 'ended';
+        call.endedAt = new Date();
+        call.duration = Math.floor((call.endedAt.getTime() - call.startedAt.getTime()) / 1000);
+        return call.save();
+    }
+    async endCallsForUser(tenantId, userId, reason) {
+        const calls = await this.callModel.find({
+            tenantId,
+            status: { $in: ['ringing', 'active'] },
+            $or: [{ initiatorId: userId }, { participantId: userId }],
+        });
+        if (calls.length === 0)
+            return [];
+        const now = new Date();
+        const callIds = calls.map(c => c._id);
+        await this.callModel.updateMany({ _id: { $in: callIds } }, {
+            $set: {
+                status: 'ended',
+                endedAt: now,
+                endReason: reason,
+            },
+        });
+        return this.callModel.find({ _id: { $in: callIds } });
+    }
+    async getCall(tenantId, callId) {
+        const call = await this.callModel.findOne({ _id: callId, tenantId });
+        if (!call)
+            throw new common_1.NotFoundException('Call not found');
+        return call;
+    }
+    async getActiveCall(tenantId, roomId) {
+        return this.callModel.findOne({ tenantId, roomId, status: { $in: ['ringing', 'active'] } });
+    }
+    async getCallHistory(tenantId, roomId, limit = 20) {
+        return this.callModel
+            .find({ tenantId, roomId, status: 'ended' })
+            .sort({ startedAt: -1 })
+            .limit(limit)
+            .exec();
+    }
+};
+exports.CallService = CallService;
+exports.CallService = CallService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, mongoose_1.InjectModel)(audiocall_schema_1.AudioCall.modelName)),
+    __metadata("design:paramtypes", [mongoose_2.Model])
+], CallService);

package/dist/services/message.service.js

@@ -0,0 +1,108 @@
+"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 MessageService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageService = void 0;
+const common_1 = require("@nestjs/common");
+const mongoose_1 = require("@nestjs/mongoose");
+const mongoose_2 = require("mongoose");
+const message_schema_1 = require("../schemas/message.schema");
+const room_schema_1 = require("../schemas/room.schema");
+let MessageService = MessageService_1 = class MessageService {
+    constructor(messageModel, roomModel) {
+        this.messageModel = messageModel;
+        this.roomModel = roomModel;
+        this.logger = new common_1.Logger(MessageService_1.name);
+    }
+    async createMessage(tenantId, dto, senderId, senderName) {
+        console.log('[MESSAGE_SERVICE] createMessage called with dto:', JSON.stringify(dto));
+        console.log('[MESSAGE_SERVICE] tenantId=', tenantId, 'senderId=', senderId, 'senderName=', senderName);
+        console.log('[MESSAGE_SERVICE] dto.roomId=', dto?.roomId, 'dto.content=', JSON.stringify(dto?.content));
+        const message = new this.messageModel({
+            ...dto,
+            tenantId,
+            senderId,
+            senderName,
+            roomId: dto.roomId,
+        });
+        console.log('[MESSAGE_SERVICE] mongoose model instance created, calling .save()...');
+        let saved;
+        try {
+            saved = await message.save();
+            console.log('[MESSAGE_SERVICE] message.save() succeeded, _id=', saved?._id);
+        }
+        catch (err) {
+            console.log('[MESSAGE_SERVICE] ERROR in message.save():', err?.message || err);
+            console.log('[MESSAGE_SERVICE] Validation errors:', JSON.stringify(err?.errors || {}));
+            console.log('[MESSAGE_SERVICE] Stack:', err?.stack);
+            throw err;
+        }
+        try {
+            await this.roomModel.updateOne({ _id: dto.roomId, tenantId }, { lastActivity: new Date(), lastMessage: saved._id });
+            console.log('[MESSAGE_SERVICE] roomModel.updateOne succeeded');
+        }
+        catch (err) {
+            console.log('[MESSAGE_SERVICE] ERROR in roomModel.updateOne (non-fatal):', err?.message || err);
+            // Don't fail the whole message send if room update fails
+        }
+        return saved;
+    }
+    async getMessages(tenantId, roomId, limit = 50, beforeCursor) {
+        const query = { tenantId, roomId };
+        if (beforeCursor) {
+            const cursorMessage = await this.messageModel.findOne({ _id: beforeCursor, tenantId });
+            if (cursorMessage) {
+                query.createdAt = { $lt: cursorMessage.createdAt };
+            }
+        }
+        const messages = await this.messageModel
+            .find(query)
+            .sort({ createdAt: -1 })
+            .limit(limit + 1)
+            .exec();
+        const hasMore = messages.length > limit;
+        const result = hasMore ? messages.slice(0, limit) : messages;
+        const nextCursor = hasMore ? result[result.length - 1]._id : null;
+        return { messages: result.reverse(), nextCursor };
+    }
+    async getMessageById(tenantId, messageId) {
+        const message = await this.messageModel.findOne({ _id: messageId, tenantId });
+        if (!message)
+            throw new common_1.NotFoundException('Message not found');
+        return message;
+    }
+    async markAsRead(tenantId, messageId, userId) {
+        await this.messageModel.updateOne({ _id: messageId, tenantId }, { $addToSet: { readBy: { userId, readAt: new Date() } } });
+    }
+    async getUnreadCount(tenantId, roomId, userId) {
+        return this.messageModel.countDocuments({
+            tenantId,
+            roomId,
+            'readBy.userId': { $ne: userId },
+        });
+    }
+    async deleteMessage(tenantId, messageId) {
+        const result = await this.messageModel.deleteOne({ _id: messageId, tenantId });
+        if (result.deletedCount === 0)
+            throw new common_1.NotFoundException('Message not found');
+    }
+};
+exports.MessageService = MessageService;
+exports.MessageService = MessageService = MessageService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, mongoose_1.InjectModel)(message_schema_1.Message.modelName)),
+    __param(1, (0, mongoose_1.InjectModel)(room_schema_1.Room.modelName)),
+    __metadata("design:paramtypes", [mongoose_2.Model,
+        mongoose_2.Model])
+], MessageService);

package/dist/services/presence.service.js

@@ -0,0 +1,65 @@
+"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 PresenceService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresenceService = void 0;
+const common_1 = require("@nestjs/common");
+const mongoose_1 = require("@nestjs/mongoose");
+const mongoose_2 = require("mongoose");
+const presence_schema_1 = require("../schemas/presence.schema");
+let PresenceService = PresenceService_1 = class PresenceService {
+    constructor(presenceModel) {
+        this.presenceModel = presenceModel;
+        this.logger = new common_1.Logger(PresenceService_1.name);
+    }
+    baseFilter(tenantId, userId) {
+        return { tenantId, userId };
+    }
+    async setOnline(tenantId, userId) {
+        return this.presenceModel.findOneAndUpdate(this.baseFilter(tenantId, userId), { status: 'online', lastSeen: new Date(), $unset: { typingIn: 1 } }, { upsert: true, new: true });
+    }
+    async setOffline(tenantId, userId) {
+        return this.presenceModel.findOneAndUpdate(this.baseFilter(tenantId, userId), { status: 'offline', lastSeen: new Date(), $unset: { typingIn: 1 } }, { upsert: true, new: true });
+    }
+    async setAway(tenantId, userId) {
+        return this.presenceModel.findOneAndUpdate(this.baseFilter(tenantId, userId), { status: 'away', lastSeen: new Date() }, { upsert: true, new: true });
+    }
+    async setStatus(tenantId, userId, dto) {
+        return this.presenceModel.findOneAndUpdate(this.baseFilter(tenantId, userId), { status: dto.status, lastSeen: new Date() }, { upsert: true, new: true });
+    }
+    async getPresence(tenantId, userId) {
+        return this.presenceModel.findOne(this.baseFilter(tenantId, userId));
+    }
+    async getPresences(tenantId, userIds) {
+        return this.presenceModel.find({ tenantId, userId: { $in: userIds } });
+    }
+    async getOnlineUsers(tenantId, userIds) {
+        return this.presenceModel.find({ tenantId, userId: { $in: userIds }, status: 'online' });
+    }
+    async setTyping(tenantId, userId, roomId) {
+        await this.presenceModel.findOneAndUpdate(this.baseFilter(tenantId, userId), { $addToSet: { typingIn: roomId } }, { upsert: true });
+    }
+    async stopTyping(tenantId, userId, roomId) {
+        await this.presenceModel.findOneAndUpdate(this.baseFilter(tenantId, userId), { $pull: { typingIn: roomId } });
+    }
+    async getTypingUsers(tenantId, roomId) {
+        return this.presenceModel.find({ tenantId, typingIn: roomId, status: 'online' });
+    }
+};
+exports.PresenceService = PresenceService;
+exports.PresenceService = PresenceService = PresenceService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, mongoose_1.InjectModel)(presence_schema_1.PresenceStatus.modelName)),
+    __metadata("design:paramtypes", [mongoose_2.Model])
+], PresenceService);

package/dist/services/room.service.js

@@ -0,0 +1,158 @@
+"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 RoomService_1;
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomService = void 0;
+const common_1 = require("@nestjs/common");
+const mongoose_1 = require("@nestjs/mongoose");
+const mongoose_2 = require("mongoose");
+const room_schema_1 = require("../schemas/room.schema");
+const chat_shared_1 = require("../../../shared/dist/index.js");
+function computeMembersHash(members) {
+    return [...new Set(members)].sort().join('|');
+}
+let RoomService = RoomService_1 = class RoomService {
+    constructor(roomModel, hooks) {
+        this.roomModel = roomModel;
+        this.hooks = hooks;
+        this.logger = new common_1.Logger(RoomService_1.name);
+    }
+    async createRoom(tenantId, dto, authContext) {
+        const uniqueMembers = Array.from(new Set([
+            ...dto.members,
+            authContext.userId,
+        ]));
+        let roomData = {
+            name: dto.name,
+            type: dto.type,
+            members: uniqueMembers,
+            membersHash: dto.type === 'direct' ? computeMembersHash(uniqueMembers) : undefined,
+            tenantId,
+            createdBy: authContext.userId,
+            lastActivity: new Date(),
+            avatar: dto.avatar,
+        };
+        if (this.hooks?.beforeRoomCreate) {
+            roomData = this.hooks.beforeRoomCreate(roomData, authContext);
+        }
+        if (roomData.type === 'direct') {
+            const existing = await this.roomModel.findOneAndUpdate({ tenantId, type: 'direct', membersHash: roomData.membersHash }, { $set: { lastActivity: new Date() } }, { new: true });
+            if (existing) {
+                if (this.hooks?.afterRoomCreate) {
+                    this.hooks.afterRoomCreate(existing);
+                }
+                return existing;
+            }
+        }
+        try {
+            const room = new this.roomModel(roomData);
+            const saved = await room.save();
+            if (this.hooks?.afterRoomCreate) {
+                this.hooks.afterRoomCreate(saved);
+            }
+            return saved;
+        }
+        catch (err) {
+            if (err?.code === 11000 && roomData.type === 'direct') {
+                const existing = await this.roomModel.findOne({
+                    tenantId,
+                    type: 'direct',
+                    membersHash: roomData.membersHash,
+                });
+                if (existing)
+                    return existing;
+            }
+            throw err;
+        }
+    }
+    async getRoom(tenantId, roomId) {
+        const room = await this.roomModel.findOne({ _id: roomId, tenantId });
+        if (!room) {
+            throw new common_1.NotFoundException('Room not found');
+        }
+        return room;
+    }
+    async getRooms(tenantId, userId, limit = 50, skip = 0) {
+        const [rooms, total] = await Promise.all([
+            this.roomModel
+                .find({ tenantId, members: userId })
+                .sort({ lastActivity: -1 })
+                .skip(skip)
+                .limit(limit + 1)
+                .exec(),
+            this.roomModel.countDocuments({ tenantId, members: userId }),
+        ]);
+        const hasMore = rooms.length > limit;
+        const result = hasMore ? rooms.slice(0, limit) : rooms;
+        return { rooms: result, hasMore };
+    }
+    async getDirectRooms(tenantId, userId) {
+        return this.roomModel
+            .find({ tenantId, members: userId, type: 'direct' })
+            .exec();
+    }
+    async findDirectRoom(tenantId, members) {
+        const uniqueMembers = Array.from(new Set(members));
+        return this.roomModel.findOne({
+            tenantId,
+            type: 'direct',
+            membersHash: computeMembersHash(uniqueMembers),
+        });
+    }
+    async findOrCreateDirectRoom(tenantId, members, authContext, name) {
+        const uniqueMembers = Array.from(new Set(members));
+        const membersHash = computeMembersHash(uniqueMembers);
+        const existingRoom = await this.roomModel.findOneAndUpdate({ tenantId, type: 'direct', membersHash }, { $set: { lastActivity: new Date() } }, { new: true });
+        if (existingRoom)
+            return existingRoom;
+        const roomName = name || `Direct: ${uniqueMembers.filter(id => id !== authContext.userId).join(', ')}`;
+        return this.createRoom(tenantId, { name: roomName, type: 'direct', members: uniqueMembers }, { ...authContext, tenantId });
+    }
+    async joinRoom(tenantId, roomId, userId) {
+        const room = await this.roomModel.findOneAndUpdate({ _id: roomId, tenantId, type: 'group' }, { $addToSet: { members: userId }, lastActivity: new Date() }, { new: true });
+        if (!room)
+            throw new common_1.NotFoundException('Room not found or not a group');
+        return room;
+    }
+    async leaveRoom(tenantId, roomId, userId) {
+        const room = await this.roomModel.findOneAndUpdate({ _id: roomId, tenantId }, { $pull: { members: userId }, lastActivity: new Date() }, { new: true });
+        if (!room)
+            throw new common_1.NotFoundException('Room not found');
+        return room;
+    }
+    async deleteRoom(tenantId, roomId, userId) {
+        const room = await this.roomModel.findOne({ _id: roomId, tenantId, createdBy: userId });
+        if (!room)
+            throw new common_1.NotFoundException('Room not found or unauthorized');
+        await this.roomModel.deleteOne({ _id: roomId, tenantId });
+    }
+    async isMember(tenantId, roomId, userId) {
+        const room = await this.roomModel.findOne({ _id: roomId, tenantId, members: userId });
+        return !!room;
+    }
+    async getRoomMembers(tenantId, roomId) {
+        const room = await this.roomModel.findOne({ _id: roomId, tenantId });
+        if (!room)
+            throw new common_1.NotFoundException('Room not found');
+        return room.members;
+    }
+};
+exports.RoomService = RoomService;
+exports.RoomService = RoomService = RoomService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, mongoose_1.InjectModel)(room_schema_1.Room.modelName)),
+    __param(1, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [mongoose_2.Model, typeof (_a = typeof chat_shared_1.ChatHooks !== "undefined" && chat_shared_1.ChatHooks) === "function" ? _a : Object])
+], RoomService);