loading time improvements

Author: andrenormanlang

apps/api/ecosystem.config.js

@@ -0,0 +1,16 @@
+module.exports = {
+  apps: [
+    {
+      name: 'mindsmesh-api',
+      script: 'dist/main.js',
+      instances: 'max', // Use maximum cores
+      exec_mode: 'cluster',
+      autorestart: true,
+      watch: false,
+      max_memory_restart: '1G',
+      env: {
+        NODE_ENV: 'production',
+      },
+    },
+  ],
+}; 

apps/api/src/app.module.ts

@@ -16,6 +16,7 @@ import { ChatModule } from './chat/chat.module';
 import { RoomsModule } from './chat/rooms.module';
 import { FirebaseModule } from './firebase/firebase.module';
 import firebaseConfig from './config/firebase.config';
+import { redisStore } from 'cache-manager-redis-store';
 
 @Module({
   imports: [
@@ -31,8 +32,11 @@ import firebaseConfig from './config/firebase.config';
       inject: [ConfigService],
     }),
     CacheModule.register({
-      ttl: 5, // Cache time-to-live in seconds
-      max: 100, // Maximum number of items in cache
+      isGlobal: true,
+      store: redisStore,
+      host: process.env.REDIS_HOST || 'localhost',
+      port: parseInt(process.env.REDIS_PORT) || 6379,
+      ttl: 60, // 60 seconds default
     }),
 
     // ThrottlerModule global configuration

apps/api/src/chat/chat.gateway.ts

@@ -16,7 +16,16 @@ import { ChatService } from './chat.service';
 import { JwtPayload } from '@/auth/interfaces/jwt-payload.interface';
 import { RoomsService } from './rooms.service';
 
-@WebSocketGateway({ cors: { origin: '*' } })
+@WebSocketGateway({
+  cors: {
+    origin: ['https://mindsmesh.vercel.app', 'https://mindsmesh.netlify.app', 'http://localhost:5173'],
+    credentials: true
+  },
+  transports: ['websocket', 'polling'],
+  pingInterval: 30000, // Ping every 30 seconds
+  pingTimeout: 10000,  // Consider connection closed if no pong within 10 seconds
+  cookie: false        // Don't use cookies for session tracking
+})
 export class ChatGateway implements OnGatewayConnection, OnGatewayDisconnect {
   @WebSocketServer()
   server: Server;

apps/api/src/common/dto/pagination.dto.ts

@@ -0,0 +1,20 @@
+import { IsOptional, IsInt, Min, Max } from 'class-validator';
+import { Type } from 'class-transformer';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class PaginationDto {
+  @ApiProperty({ required: false, default: 1 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  page?: number = 1;
+
+  @ApiProperty({ required: false, default: 10 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  @Max(100)
+  limit?: number = 10;
+} 

apps/api/src/common/interceptors/etag.interceptor.ts

@@ -0,0 +1,29 @@
+import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { createHash } from 'crypto';
+
+@Injectable()
+export class EtagInterceptor implements NestInterceptor {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    return next.handle().pipe(
+      map(data => {
+        const response = context.switchToHttp().getResponse();
+        const request = context.switchToHttp().getRequest();
+        
+        // Generate ETag from response data
+        const etag = createHash('md5').update(JSON.stringify(data)).digest('hex');
+        response.setHeader('ETag', etag);
+        
+        // Check if client has matching ETag
+        const ifNoneMatch = request.headers['if-none-match'];
+        if (ifNoneMatch === etag) {
+          response.status(304).send();
+          return null;
+        }
+        
+        return data;
+      }),
+    );
+  }
+} 

apps/api/src/common/interceptors/timeout.interceptor.ts

@@ -0,0 +1,18 @@
+import { Injectable, NestInterceptor, ExecutionContext, CallHandler, RequestTimeoutException } from '@nestjs/common';
+import { Observable, throwError, TimeoutError } from 'rxjs';
+import { catchError, timeout } from 'rxjs/operators';
+
+@Injectable()
+export class TimeoutInterceptor implements NestInterceptor {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    return next.handle().pipe(
+      timeout(10000), // 10 seconds timeout
+      catchError(err => {
+        if (err instanceof TimeoutError) {
+          return throwError(() => new RequestTimeoutException('Request timeout'));
+        }
+        return throwError(() => err);
+      }),
+    );
+  }
+} 

apps/api/src/common/interceptors/transform.interceptor.ts

@@ -0,0 +1,20 @@
+import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+export interface Response<T> {
+  data: T;
+  timestamp: number;
+}
+
+@Injectable()
+export class TransformInterceptor<T> implements NestInterceptor<T, Response<T>> {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<Response<T>> {
+    return next.handle().pipe(
+      map(data => ({
+        data,
+        timestamp: Date.now(),
+      })),
+    );
+  }
+} 

apps/api/src/config/typeorm.ts

@@ -10,16 +10,19 @@ const config = {
   entities: ["dist/**/*.entity{.ts,.js}"],
   migrations: ["dist/migrations/*{.ts,.js}"],
   autoLoadEntities: true,
-  synchronize: true, 
+  synchronize: false,
   ssl: true,
   extra: {
     ssl: {
       rejectUnauthorized: false,
     },
-    connectionTimeoutMillis: 30000, 
+    connectionTimeoutMillis: 10000,
     idleTimeoutMillis: 30000,       
-    max: 10,                        
+    max: 20,                        
+    min: 5,                        
+    maxUses: 7500,                 
   },
+  logging: process.env.NODE_ENV === 'development' ? ['query', 'error'] : ['error'],
 } as DataSourceOptions;
 
 export default registerAs('typeorm', () => config);

apps/api/src/main.ts

@@ -3,6 +3,9 @@ import { AppModule } from './app.module';
 import { ValidationPipe, Logger } from '@nestjs/common';
 import * as bodyParser from 'body-parser';
 import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
+import * as compression from 'compression';
+import { TransformInterceptor } from './common/interceptors/transform.interceptor';
+import { LoggingInterceptor } from './common/interceptors/logging.interceptor';
 
 async function bootstrap() {
   const logger = new Logger('Bootstrap');
@@ -30,6 +33,10 @@ async function bootstrap() {
     allowedHeaders: 'Content-Type, Authorization',
     credentials: true, 
   });
+
+  // Add compression
+  app.use(compression());
+
   // Swagger configuration
   const config = new DocumentBuilder()
     .setTitle('API Documentation')
@@ -40,6 +47,12 @@ async function bootstrap() {
   const document = SwaggerModule.createDocument(app, config);
   SwaggerModule.setup('api-docs', app, document);
 
+  // Add global interceptors
+  app.useGlobalInterceptors(
+    new TransformInterceptor(),
+    new LoggingInterceptor(),
+  );
+
   const PORT = process.env.PORT || 3000;
 
   // Start listening on the specified PORT and bind to all network interfaces

apps/api/src/users/entities/user.entity.ts

@@ -1,12 +1,14 @@
 import { ApiProperty, ApiHideProperty } from '@nestjs/swagger';
-import { Entity, PrimaryGeneratedColumn, Column, OneToMany } from 'typeorm';
+import { Entity, PrimaryGeneratedColumn, Column, OneToMany, Index } from 'typeorm';
 import { Skill } from '../../skills/entities/skill.entity';
 import { IsOptional } from 'class-validator';
 import { ChatMessage } from '@/chat/entities/chat-message.entity';
 import { UserRole } from '../enums/user-role.enum';
 import { Room } from '@/chat/entities/room.entity';
 
 @Entity()
+@Index(['email'])
+@Index(['role'])
 export class User {
   @ApiProperty({
     example: 'uuid-1234',