@enfin/chat-server 1.2.0

package/README.md

@@ -0,0 +1,278 @@
+# @enfin/chat-server
+
+NestJS chat module — Socket.IO gateway, MongoDB persistence, file uploads, presence, and audio calls.
+
+## Install
+
+```bash
+npm install @enfin/chat-server @enfin/chat-shared
+```
+
+## Quick Start (CLI)
+
+For quick local testing:
+
+```bash
+npx chat-server start --apiKey=chat_xxx --port=3002
+```
+
+Options:
+- `--apiKey` (required): Your API key
+- `--port` (default: 3002): Server port
+- `--mongoUri` (default: mongodb://localhost:27017/chat_sdk): MongoDB connection string
+- `--mode` (default: managed): `managed` or `external-db`
+
+## Mount in Your NestJS App
+
+### Option 1: Fresh MongoDB (no existing Mongoose)
+
+Use `ChatMongooseModule` to create the connection, then mount `ChatModule`:
+
+```ts
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { ChatMongooseModule, ChatModule } from '@enfin/chat-server';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({ isGlobal: true }),
+    ChatMongooseModule.forRoot(process.env.MONGO_URI || 'mongodb://localhost:27017/myapp'),
+    ChatModule.forRoot({
+      apiKey: process.env.CHAT_API_KEY || 'chat_xxx',
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### Option 2: Already Have Mongoose
+
+If your app already calls `MongooseModule.forRoot(uri)`, skip `ChatMongooseModule`:
+
+```ts
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { MongooseModule } from '@nestjs/mongoose';
+import { ChatModule } from '@enfin/chat-server';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({ isGlobal: true }),
+    MongooseModule.forRoot('mongodb://localhost:27017/myapp'),
+    ChatModule.forRoot({
+      apiKey: process.env.CHAT_API_KEY || 'chat_xxx',
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+ChatModule registers its schemas on whatever Mongoose connection exists.
+
+## ChatModuleOptions
+
+| Option | Type | Required | Description |
+|--------|------|----------|-------------|
+| `apiKey` | string | Yes | Your platform API key |
+| `mongoUri` | string | No | Customer-provided DB (external-db mode) |
+| `mode` | `'managed'` \| `'external-db'` | No | Default: `managed` |
+| `version` | string | No | API version string |
+| `platformMongoUri` | string | No | Platform DB for key validation |
+| `uploadDir` | string | No | Where uploaded files are written. Relative paths resolve against `process.cwd()`. Overrides `UPLOAD_DIR` env. |
+| `fileUploadHandler` | function | No | Custom upload handler. Receives the parsed file and returns the URL. Use for S3 / Azure / GCS. See [Custom file upload handler](#custom-file-upload-handler). |
+
+## Modes
+
+### `managed` (default)
+
+The chat server validates API keys against its own database. Use this when you control the keys and want the server to manage everything.
+
+### `external-db`
+
+The customer provides their own MongoDB. The server stores chat data there but still validates keys against your platform. Use this for customers who want isolation.
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `MONGO_URI` | Fallback MongoDB URI (used if not provided in options) |
+| `PORT` | Server port (default: 3002) |
+| `UPLOAD_DIR` | Where uploaded files are written. Relative paths resolve against `process.cwd()` (e.g. `public/images` → `<cwd>/public/images`). Absolute paths are used as-is. Default: `uploads` (i.e. `<cwd>/uploads`). |
+
+### Configuring the upload directory
+
+Resolution order: `options.uploadDir` → `process.env.UPLOAD_DIR` → `uploads` (relative to cwd).
+
+```bash
+# Default: <cwd>/uploads
+node dist/main.js
+
+# Relative path: <cwd>/public/images  (the file URL is still /uploads/<uuid>.<ext>)
+UPLOAD_DIR=public/images node dist/main.js
+
+# Absolute path
+UPLOAD_DIR=/var/data/chat-uploads node dist/main.js
+```
+
+Or in NestJS options:
+
+```ts
+ChatModule.forRoot({
+  apiKey: process.env.CHAT_API_KEY!,
+  uploadDir: 'public/images',   // resolves to <cwd>/public/images
+}),
+```
+
+The directory is created automatically on startup if it does not exist. Uploaded files are served at `GET /uploads/<filename>` (handled by `ChatModule` — no extra `useStaticAssets` needed in your `main.ts`).
+
+### Custom file upload handler
+
+For production deployments you usually want files in object storage (S3, Azure Blob, Google Cloud Storage) instead of on the chat server's disk. Pass a `fileUploadHandler` to `ChatModule.forRoot` to take over the upload step.
+
+The handler receives the file (already parsed by multer — `file.path` is on local disk and `file.buffer` is in memory) plus the validated `tenantId` and `roomId`, and returns the URL where the file is now reachable. The URL is stored in the `Message` exactly like the default behaviour — no frontend changes are needed.
+
+```ts
+import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
+import { ChatModule, FileUploadHandler } from '@enfin/chat-server';
+
+const s3 = new S3Client({ region: 'us-east-1' });
+
+const uploadToS3: FileUploadHandler = async ({ file, tenantId, roomId }) => {
+  const key = `${tenantId}/${roomId}/${Date.now()}-${file.originalname}`;
+  await s3.send(new PutObjectCommand({
+    Bucket: 'my-chat-uploads',
+    Key: key,
+    Body: file.buffer ?? require('fs').createReadStream(file.path),
+    ContentType: file.mimetype,
+  }));
+  return {
+    fileUrl: `https://my-chat-uploads.s3.amazonaws.com/${key}`,
+    fileName: file.originalname,
+    fileType: file.mimetype,
+    fileSize: file.size,
+  };
+};
+
+ChatModule.forRoot({
+  apiKey: process.env.CHAT_API_KEY!,
+  fileUploadHandler: uploadToS3,
+});
+```
+
+**Notes:**
+
+- If `fileUploadHandler` is not provided, the default multer-to-disk behaviour is unchanged.
+- The handler is called **after** API key and room validation, so it only ever sees authorised uploads.
+- Return any URL the frontend can `fetch` — absolute (S3, CDN) or relative (your own CDN in front of the bucket).
+- For tenant isolation, namespace the storage key with `tenantId` (as shown above) so tenants cannot read each other's files.
+- The built-in `GET /uploads/<filename>` route is still registered but will be unused when you return external URLs. It is harmless to leave in place.
+
+## REST Endpoints
+
+All endpoints require `x-api-key` header unless noted.
+
+| Method | Path | Description |
+|--------|-----|-------------|
+| `POST` | `/api/validation/validate` | Validate API key |
+| `POST` | `/api/users/register` | Register a user |
+| `GET` | `/api/users` | List all users (with presence) |
+| `GET` | `/api/rooms` | List rooms for a user |
+| `POST` | `/api/rooms/direct` | Open/get direct room |
+| `GET` | `/api/rooms/:roomId/messages` | Get room messages |
+| `POST` | `/api/upload` | Upload file (multipart/form-data) |
+
+## Socket Events
+
+Namespace: `/chat`
+
+### Connect
+
+Handshake auth required:
+
+```ts
+socket = io('http://localhost:3002/chat', {
+  auth: { apiKey: 'chat_xxx', userId: 'u1', userName: 'Alice' }
+});
+```
+
+### Client → Server
+
+| Event | Payload | Description |
+|-------|--------|-------------|
+| `message` | `{ roomId, content }` | Send message |
+| `typing` | `{ roomId, isTyping }` | Typing indicator |
+| `presence` | `{ status }` | Set presence (online/away/offline) |
+| `join-room` | `{ roomId }` | Join a room |
+| `leave-room` | `{ roomId }` | Leave a room |
+| `call` | `{ to, offer }` | WebRTC offer |
+| `call-accept` | `{ callId, answer }` | WebRTC answer |
+| `call-reject` | `{ callId }` | Reject call |
+| `call-end` | `{ callId }` | End call |
+
+### Server → Client
+
+| Event | Payload | Description |
+|-------|--------|-------------|
+| `message` | `{ roomId, messages[] }` | New message(s) |
+| `typing` | `{ roomId, userId, isTyping }` | User typing |
+| `presence:changed` | `{ userId, status }` | Presence update |
+| `room:updated` | `{ room }` | Room updated |
+| `call` | `{ callId, from, offer }` | Incoming call |
+| `call-accepted` | `{ callId, answer }` | Call accepted |
+| `call-rejected` | `{ callId }` | Call rejected |
+| `call-ended` | `{ callId }` | Call ended |
+| `error` | `{ code, message }` | Error event |
+| `users:list` | `{ users[] }` | User list on join |
+
+## File Uploads
+
+POST to `/api/upload` with `multipart/form-data`:
+
+- Field: `file`
+- Header: `x-api-key`
+- Body: `{ roomId: string }`
+
+Response:
+
+```json
+{
+  "success": true,
+  "fileUrl": "/uploads/uuid-filename.jpg",
+  "fileName": "photo.jpg",
+  "fileType": "image/jpeg",
+  "fileSize": 12345
+}
+```
+
+Max file size: 50MB. Files are served at `GET /uploads/<filename>` by the SDK's built-in controller — you do not need to register `useStaticAssets` in your `main.ts`.
+
+> **Production:** the built-in disk storage is for development and small deployments. For production pass a `fileUploadHandler` to `ChatModule.forRoot` that streams the file to S3 / Azure Blob / GCS and returns the public URL. See [Custom file upload handler](#custom-file-upload-handler).
+
+## Troubleshooting
+
+### EADDRINUSE
+
+Another process is on your port. Kill it or use a different port:
+
+```bash
+# Find process
+netstat -ano | findstr :3002
+# Kill on Windows
+taskkill /PID <pid> /F
+```
+
+### MongoDB connection failed
+
+Ensure MongoDB is running and the URI is correct. If using Docker:
+
+```bash
+docker run -d -p 27017:27017 mongo
+```
+
+### Invalid apiKey
+
+Keys must exist in your platform database. In `managed` mode, the server looks up the key on startup. In `external-db` mode, provide valid keys in your customer's DB.
+
+---
+
+For frontend SDK, see `@shuhaib-enfin/chat`.

package/dist/bin/start.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Standalone CLI entry point for the chat server.
+ *
+ * Usage:
+ *   npx chat-server start --apiKey=chat_xxx --port=3002
+ *   npx chat-server start --apiKey=chat_xxx --mongoUri=mongodb://localhost:27017/mydb
+ *
+ * This is intended for quick testing / local dev only.
+ * In production, mount ChatModule.forRoot in your own NestJS app.
+ */
+require("reflect-metadata");
+const core_1 = require("@nestjs/core");
+const common_1 = require("@nestjs/common");
+const chat_module_1 = require("../chat.module");
+function parseArgs() {
+    const args = {};
+    const argv = process.argv.slice(2);
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === 'start' && i + 1 < argv.length) {
+            const next = argv[i + 1];
+            if (!next.startsWith('--')) {
+                i++;
+                continue;
+            }
+        }
+        if (arg.startsWith('--apiKey=')) {
+            args.apiKey = arg.split('=')[1];
+        }
+        else if (arg === '--apiKey' && i + 1 < argv.length) {
+            args.apiKey = argv[++i];
+        }
+        if (arg.startsWith('--port=')) {
+            args.port = arg.split('=')[1];
+        }
+        else if (arg === '--port' && i + 1 < argv.length) {
+            args.port = argv[++i];
+        }
+        if (arg.startsWith('--mongoUri=')) {
+            args.mongoUri = arg.split('=')[1];
+        }
+        else if (arg === '--mongoUri' && i + 1 < argv.length) {
+            args.mongoUri = argv[++i];
+        }
+        if (arg.startsWith('--mode=')) {
+            args.mode = arg.split('=')[1];
+        }
+        else if (arg === '--mode' && i + 1 < argv.length) {
+            args.mode = argv[++i];
+        }
+    }
+    return args;
+}
+async function bootstrap() {
+    const args = parseArgs();
+    if (!args.apiKey) {
+        console.error('Error: --apiKey is required');
+        console.error('Usage: npx chat-server start --apiKey=chat_xxx [--port=3002] [--mongoUri=mongodb://...]');
+        process.exit(1);
+    }
+    const port = args.port || '3002';
+    const mongoUri = args.mongoUri || 'mongodb://localhost:27017/chat_sdk';
+    const mode = args.mode || 'managed';
+    console.log(`Starting chat-server on port ${port}...`);
+    console.log(`API Key: ${args.apiKey.slice(0, 12)}...`);
+    console.log(`MongoDB: ${mongoUri}`);
+    console.log(`Mode: ${mode}`);
+    const app = await core_1.NestFactory.create(chat_module_1.ChatModule.forRoot({
+        apiKey: args.apiKey,
+        mongoUri,
+        mode,
+    }));
+    app.enableCors({
+        origin: '*',
+        credentials: true,
+    });
+    app.useGlobalPipes(new common_1.ValidationPipe({
+        whitelist: true,
+        transform: true,
+    }));
+    app.setGlobalPrefix('api');
+    await app.listen(port);
+    console.log(`Chat server running at http://localhost:${port}`);
+    console.log(`API prefix: /api`);
+}
+bootstrap().catch((err) => {
+    console.error('Failed to start:', err);
+    process.exit(1);
+});

package/dist/chat-mongoose.module.js

@@ -0,0 +1,48 @@
+"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 ChatMongooseModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatMongooseModule = void 0;
+const common_1 = require("@nestjs/common");
+const mongoose_1 = require("@nestjs/mongoose");
+/**
+ * Helper module for hosts that do NOT already have a Mongoose connection.
+ *
+ * Use this BEFORE ChatModule.forRoot when your NestJS app is starting fresh
+ * and you want the chat SDK to manage MongoDB. If you already call
+ * MongooseModule.forRoot in your own app, skip this and just import
+ * ChatModule.forRoot — schemas are registered on whatever connection exists.
+ *
+ * Example:
+ *
+ *   @Module({
+ *     imports: [
+ *       ChatMongooseModule.forRoot('mongodb://localhost:27017/myapp'),
+ *       ChatModule.forRoot({ apiKey: 'chat_xxx' }),
+ *     ],
+ *   })
+ *   export class AppModule {}
+ *
+ * Note: We use `global: true` on the DynamicModule metadata instead of the
+ * @Global() class decorator. The combination of @Global() + DynamicModule
+ * is the root cause of "Nest can't resolve dependencies of the MongooseCoreModule
+ * (MongooseConnectionName, ?)" in NestJS 10.4.
+ */
+let ChatMongooseModule = ChatMongooseModule_1 = class ChatMongooseModule {
+    static forRoot(uri) {
+        return {
+            module: ChatMongooseModule_1,
+            imports: [mongoose_1.MongooseModule.forRoot(uri)],
+            exports: [mongoose_1.MongooseModule],
+        };
+    }
+};
+exports.ChatMongooseModule = ChatMongooseModule;
+exports.ChatMongooseModule = ChatMongooseModule = ChatMongooseModule_1 = __decorate([
+    (0, common_1.Module)({})
+], ChatMongooseModule);

package/dist/chat.constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHAT_TENANT_ID = exports.CHAT_MODULE_OPTIONS = void 0;
+exports.CHAT_MODULE_OPTIONS = 'CHAT_MODULE_OPTIONS';
+exports.CHAT_TENANT_ID = 'CHAT_TENANT_ID';

package/dist/chat.module.js

@@ -0,0 +1,144 @@
+"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.ChatModule = exports.ChatUploadsController = exports.CHAT_UPLOAD_HANDLER = exports.CHAT_UPLOAD_DIR = exports.CHAT_TENANT_ID = exports.CHAT_MODULE_OPTIONS = void 0;
+const common_1 = require("@nestjs/common");
+const mongoose_1 = require("@nestjs/mongoose");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const chat_gateway_1 = require("./gateways/chat.gateway");
+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 storage_service_1 = require("./services/storage/storage.service");
+const rate_limiter_service_1 = require("./services/storage/rate-limiter.service");
+const schemas_1 = require("./schemas");
+const apikey_service_1 = require("./services/apikey.service");
+const validation_controller_1 = require("./controllers/validation.controller");
+const users_controller_1 = require("./controllers/users.controller");
+const rooms_controller_1 = require("./controllers/rooms.controller");
+const upload_controller_1 = require("./controllers/upload.controller");
+// IMPORTANT: Keep these as inline string literals (not module-level references) in any
+// other file that imports from chat.module — circular imports cause the export to be
+// undefined at decorator-evaluation time in CommonJS output. Use the string directly.
+exports.CHAT_MODULE_OPTIONS = 'CHAT_MODULE_OPTIONS';
+exports.CHAT_TENANT_ID = 'CHAT_TENANT_ID';
+exports.CHAT_UPLOAD_DIR = 'CHAT_UPLOAD_DIR';
+exports.CHAT_UPLOAD_HANDLER = 'CHAT_UPLOAD_HANDLER';
+const logger = new common_1.Logger('ChatModule');
+function resolveUploadDir(override) {
+    // Precedence: explicit option > UPLOAD_DIR env > default 'uploads' (relative to cwd)
+    // Relative paths (e.g. 'public/images', 'uploads') are resolved against cwd.
+    // Absolute paths (e.g. '/var/data/chat', 'C:\\storage\\chat') are used as-is.
+    const raw = override || process.env.UPLOAD_DIR || 'uploads';
+    const dir = (0, path_1.isAbsolute)(raw) ? raw : (0, path_1.join)(process.cwd(), raw);
+    if (!(0, fs_1.existsSync)(dir)) {
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+    }
+    return dir;
+}
+let ChatUploadsController = class ChatUploadsController {
+    constructor(uploadDir) {
+        this.uploadDir = uploadDir;
+    }
+    serveFile(filename, res) {
+        if (!filename || filename.includes('..') || filename.includes('\\') || filename.includes('/')) {
+            throw new common_1.BadRequestException('Invalid filename');
+        }
+        const filePath = (0, path_1.join)(this.uploadDir, filename);
+        if (!(0, fs_1.existsSync)(filePath)) {
+            throw new common_1.NotFoundException('File not found');
+        }
+        res.sendFile(filePath, (err) => {
+            if (err && !res.headersSent) {
+                res.status(500).end('Server error');
+            }
+        });
+    }
+};
+exports.ChatUploadsController = ChatUploadsController;
+__decorate([
+    (0, common_1.Get)(':filename'),
+    __param(0, (0, common_1.Param)('filename')),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", void 0)
+], ChatUploadsController.prototype, "serveFile", null);
+exports.ChatUploadsController = ChatUploadsController = __decorate([
+    (0, common_1.Controller)('uploads'),
+    __param(0, (0, common_1.Inject)('CHAT_UPLOAD_DIR')),
+    __metadata("design:paramtypes", [String])
+], ChatUploadsController);
+class ChatModule {
+    static forRoot(options) {
+        const mode = options.mode || 'managed';
+        const platformMongoUri = options.platformMongoUri || process.env.MONGO_URI || 'mongodb://localhost:27017/chat_sdk';
+        const customerMongoUri = options.mongoUri;
+        const adminValidationUrl = options.adminValidationUrl || process.env.ADMIN_API_VALIDATION_URL;
+        const finalMongoUri = customerMongoUri && customerMongoUri.trim().length > 0 ? customerMongoUri : platformMongoUri;
+        const uploadDir = resolveUploadDir(options.uploadDir);
+        logger.log(`========================================`);
+        logger.log(`[ChatModule.forRoot] mode=${mode}`);
+        logger.log(`[ChatModule.forRoot] apiKey=${options.apiKey?.slice(0, 12)}...`);
+        logger.log(`[ChatModule.forRoot] mongoUri=${finalMongoUri}`);
+        logger.log(`[ChatModule.forRoot] platformMongoUri=${platformMongoUri}`);
+        logger.log(`[ChatModule.forRoot] customerMongoUri=${customerMongoUri || '(not provided — using platform DB)'}`);
+        logger.log(`[ChatModule.forRoot] uploadDir=${uploadDir}`);
+        logger.log(`========================================`);
+        const optionsProvider = {
+            provide: exports.CHAT_MODULE_OPTIONS,
+            useValue: {
+                ...options,
+                mode,
+                mongoUri: finalMongoUri,
+                platformMongoUri,
+                adminValidationUrl,
+                uploadDir,
+            },
+        };
+        const uploadDirProvider = {
+            provide: exports.CHAT_UPLOAD_DIR,
+            useValue: uploadDir,
+        };
+        const uploadHandlerProvider = {
+            provide: exports.CHAT_UPLOAD_HANDLER,
+            useValue: options.fileUploadHandler,
+        };
+        logger.log(`[ChatModule.forRoot] adminValidationUrl=${adminValidationUrl || '(not set — apiKey validation will fail)'}`);
+        logger.log(`[ChatModule.forRoot] fileUploadHandler=${options.fileUploadHandler ? 'custom' : 'default (multer disk)'}`);
+        return {
+            module: ChatModule,
+            imports: [
+                mongoose_1.MongooseModule.forFeature(schemas_1.schemas),
+            ],
+            providers: [
+                optionsProvider,
+                uploadDirProvider,
+                uploadHandlerProvider,
+                chat_gateway_1.ChatGateway,
+                message_service_1.MessageService,
+                room_service_1.RoomService,
+                presence_service_1.PresenceService,
+                call_service_1.CallService,
+                apikey_service_1.ApiKeyService,
+                storage_service_1.StorageService,
+                rate_limiter_service_1.RateLimiterService,
+            ],
+            controllers: [users_controller_1.UsersController, validation_controller_1.ValidationController, rooms_controller_1.RoomsController, upload_controller_1.UploadController, ChatUploadsController],
+        };
+    }
+}
+exports.ChatModule = ChatModule;

package/dist/controllers/rooms.controller.js

@@ -0,0 +1,112 @@
+"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.RoomsController = void 0;
+const common_1 = require("@nestjs/common");
+const room_service_1 = require("../services/room.service");
+const message_service_1 = require("../services/message.service");
+const apikey_service_1 = require("../services/apikey.service");
+let RoomsController = class RoomsController {
+    constructor(roomService, messageService, apiKeyService) {
+        this.roomService = roomService;
+        this.messageService = messageService;
+        this.apiKeyService = apiKeyService;
+    }
+    async resolveTenant(apiKey) {
+        const result = await this.apiKeyService.validateKey(apiKey);
+        if (!result.valid) {
+            throw new common_1.BadRequestException(result.error || 'Invalid apiKey');
+        }
+        return result.tenantId;
+    }
+    async listRooms(apiKey, userId, limit, skip) {
+        if (!apiKey) {
+            throw new common_1.BadRequestException('x-api-key header is required');
+        }
+        if (!userId) {
+            throw new common_1.BadRequestException('userId query param is required');
+        }
+        const tenantId = await this.resolveTenant(apiKey);
+        const parsedLimit = limit ? Math.min(Math.max(parseInt(limit, 10) || 50, 1), 200) : 50;
+        const parsedSkip = skip ? Math.max(parseInt(skip, 10) || 0, 0) : 0;
+        return this.roomService.getRooms(tenantId, userId, parsedLimit, parsedSkip);
+    }
+    async openDirectRoom(body) {
+        if (!body.userId || !Array.isArray(body.members) || body.members.length < 2) {
+            throw new common_1.BadRequestException('userId and members array are required');
+        }
+        if (!body.apiKey) {
+            throw new common_1.BadRequestException('apiKey is required');
+        }
+        const tenantId = await this.resolveTenant(body.apiKey);
+        const uniqueMembers = Array.from(new Set(body.members));
+        if (!uniqueMembers.includes(body.userId)) {
+            uniqueMembers.push(body.userId);
+        }
+        const room = await this.roomService.findOrCreateDirectRoom(tenantId, uniqueMembers, { userId: body.userId }, body.name);
+        const messages = await this.messageService.getMessages(tenantId, room._id);
+        return { room, messages: messages.messages };
+    }
+    async getRoomMessages(roomId, apiKey) {
+        if (!apiKey) {
+            throw new common_1.BadRequestException('x-api-key header is required');
+        }
+        const tenantId = await this.resolveTenant(apiKey);
+        console.log('========================================');
+        console.log('[CONTROLLER] GET rooms/:roomId/messages');
+        console.log('[CONTROLLER] roomId param =', roomId, 'type =', typeof roomId);
+        console.log('[CONTROLLER] tenantId =', tenantId);
+        console.log('========================================');
+        const messages = await this.messageService.getMessages(tenantId, roomId);
+        console.log(`[CONTROLLER] messageService.getMessages returned:`, JSON.stringify({
+            messageCount: messages?.messages?.length,
+            firstMessageId: messages?.messages?.[0]?._id,
+            firstMessageRoomId: messages?.messages?.[0]?.roomId,
+            firstMessageRoomIdType: typeof messages?.messages?.[0]?.roomId,
+        }));
+        return messages;
+    }
+};
+exports.RoomsController = RoomsController;
+__decorate([
+    (0, common_1.Get)(),
+    __param(0, (0, common_1.Headers)('x-api-key')),
+    __param(1, (0, common_1.Query)('userId')),
+    __param(2, (0, common_1.Query)('limit')),
+    __param(3, (0, common_1.Query)('skip')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, String]),
+    __metadata("design:returntype", Promise)
+], RoomsController.prototype, "listRooms", null);
+__decorate([
+    (0, common_1.Post)('direct'),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], RoomsController.prototype, "openDirectRoom", null);
+__decorate([
+    (0, common_1.Get)(':roomId/messages'),
+    __param(0, (0, common_1.Param)('roomId')),
+    __param(1, (0, common_1.Headers)('x-api-key')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], RoomsController.prototype, "getRoomMessages", null);
+exports.RoomsController = RoomsController = __decorate([
+    (0, common_1.Controller)('rooms'),
+    __metadata("design:paramtypes", [room_service_1.RoomService,
+        message_service_1.MessageService,
+        apikey_service_1.ApiKeyService])
+], RoomsController);