@optimatech88/titomeet-shared-lib 1.0.25 → 1.0.26

package/.github/workflows/npm-publish.yml

@@ -1,34 +1,34 @@
-# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
-# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
-
-name: Node.js Package
-
-on:
-  push:
-    branches:
-      - main # Or your main branch
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-      - run: npm ci
-      - run: npm run build
-
-  publish-npm:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          registry-url: https://registry.npmjs.org/
-      - run: npm ci
-      - run: npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  push:
+    branches:
+      - main # Or your main branch
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npm run build
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/.prettierrc

@@ -1,5 +1,5 @@
-{
-  "singleQuote": true,
-  "trailingComma": "all",
-  "endOfLine":"auto"
+{
+  "singleQuote": true,
+  "trailingComma": "all",
+  "endOfLine":"auto"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optimatech88/titomeet-shared-lib",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {

package/prisma/schema.prisma

@@ -20,6 +20,12 @@ enum UserRole {
   USER
 }
 
+enum UserStatus {
+  ACTIVE
+  INACTIVE
+  DELETED
+}
+
 model User {
   id        String  @id @default(cuid())
   username  String   @unique
@@ -31,6 +37,7 @@ model User {
 
   profilePicture String?
   emailVerified Boolean @default(false)
+  status UserStatus @default(ACTIVE)
 
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
@@ -181,6 +188,13 @@ model ChatUser {
   updatedAt DateTime  @updatedAt
 }
 
+enum MediaType {
+  image
+  video
+  audio
+  pdf
+}
+
 model Message {
   id          String    @id @default(cuid())
   text     String
@@ -190,6 +204,7 @@ model Message {
   senderId    String
 
   mediaUrl String?
+  mediaType MediaType?
 
   createdAt   DateTime  @default(now())
   updatedAt   DateTime  @updatedAt

package/src/auth/admin.middleware.ts

@@ -1,20 +1,20 @@
-import { Injectable, NestMiddleware, UnauthorizedException } from '@nestjs/common';
-import { Request, Response, NextFunction } from 'express';
-import { UserRole, User } from '@prisma/client';
-
-interface RequestWithUser extends Request {
-  user?: User;
-}
-
-@Injectable()
-export class AdminMiddleware implements NestMiddleware {
-  use(req: RequestWithUser, res: Response, next: NextFunction) {
-    const user = req.user;
-
-    if (!user || !user.role?.includes(UserRole.ADMIN)) {
-      throw new UnauthorizedException('Access denied. Admins only.');
-    }
-
-    next();
-  }
-}
+import { Injectable, NestMiddleware, UnauthorizedException } from '@nestjs/common';
+import { Request, Response, NextFunction } from 'express';
+import { UserRole, User } from '@prisma/client';
+
+interface RequestWithUser extends Request {
+  user?: User;
+}
+
+@Injectable()
+export class AdminMiddleware implements NestMiddleware {
+  use(req: RequestWithUser, res: Response, next: NextFunction) {
+    const user = req.user;
+
+    if (!user || !user.role?.includes(UserRole.ADMIN)) {
+      throw new UnauthorizedException('Access denied. Admins only.');
+    }
+
+    next();
+  }
+}

package/src/auth/auth.guard.ts

@@ -1,154 +1,154 @@
-import {
-  CanActivate,
-  ExecutionContext,
-  Injectable,
-  UnauthorizedException,
-} from '@nestjs/common';
-import { JwtService } from '@nestjs/jwt';
-import { PrismaClient, UserRole } from '@prisma/client';
-import { Request } from 'express';
-import { IncomingHttpHeaders } from 'http';
-import { Logger } from '@nestjs/common';
-
-@Injectable()
-export class AuthGuard implements CanActivate {
-  private prisma: PrismaClient;
-  private logger = new Logger(AuthGuard.name);
-
-  constructor(
-    private jwtService: JwtService,
-  ) {
-    this.prisma = new PrismaClient();
-  }
-
-  async canActivate(context: ExecutionContext): Promise<boolean> {
-    this.logger.log('canActivate');
-    const request = context.switchToHttp().getRequest();
-    const token = this.extractTokenFromHeader(request);
-    if (!token) {
-      throw new UnauthorizedException();
-    }
-    try {
-      const payload = (await this.jwtService.verifyAsync(token)) as {
-        userId: string;
-      };
-
-      this.logger.log('payload', payload);
-
-      const user = await this.prisma.user.findUnique({
-        where: { id: payload.userId }
-      });
-
-      this.logger.log('user', user);
-
-      if (!user) {
-        throw new UnauthorizedException();
-      }
-
-      request['user'] = user;
-    } catch {
-      throw new UnauthorizedException();
-    }
-    return true;
-  }
-
-  private extractTokenFromHeader(request: Request & { headers: IncomingHttpHeaders }): string | undefined {
-    const [type, token] = request.headers.authorization?.split(' ') ?? [];
-    this.logger.log('extractTokenFromHeader', {type, token});
-    return type === 'Bearer' ? token : undefined;
-  }
-}
-
-//optional auth guard
-@Injectable()
-export class OptionalAuthGuard implements CanActivate {
-   private prisma: PrismaClient;
-
-  constructor(
-    private jwtService: JwtService,
-  ) {
-    this.prisma = new PrismaClient();
-  }
-
-  async canActivate(context: ExecutionContext): Promise<boolean> {
-    const request = context.switchToHttp().getRequest();
-    const token = this.extractTokenFromHeader(request);
-    if (!token) {
-      return true;
-    }
-    try {
-      const payload = (await this.jwtService.verifyAsync(token)) as {
-        userId: string;
-      };
-
-      const user = await this.prisma.user.findUnique({
-        where: { id: payload.userId }
-      });
-
-      if (!user) {
-        throw new UnauthorizedException();
-      }
-
-      request['user'] = user;
-
-      // Continue without setting user
-    } catch {
-      // Continue without setting user
-    }
-    return true;
-  }
-
-  private extractTokenFromHeader(request: Request & { headers: IncomingHttpHeaders }): string | undefined {
-    const [type, token] = request.headers.authorization?.split(' ') ?? [];
-    return type === 'Bearer' ? token : undefined;
-  }
-}
-
-//admin auth guard
-@Injectable()
-export class AdminAuthGuard implements CanActivate {
-  private prisma: PrismaClient;
-
-  constructor(
-    private jwtService: JwtService,
-  ) {
-    this.prisma = new PrismaClient();
-  }
-
-  async canActivate(context: ExecutionContext): Promise<boolean> {
-    const request = context.switchToHttp().getRequest();
-    const token = this.extractTokenFromHeader(request);
-    if (!token) {
-      throw new UnauthorizedException();
-    }
-    try {
-      const payload = (await this.jwtService.verifyAsync(token)) as {
-        userId: string;
-      };
-
-      const user = await this.prisma.user.findUnique({
-        where: { id: payload.userId }
-      });
-
-      if (!user) {
-        throw new UnauthorizedException();
-      }
-
-      if(user.role !== UserRole.ADMIN && user.role !== UserRole.SUPER_ADMIN) {
-        throw new UnauthorizedException();
-      }
-
-      request['user'] = user;
-    } catch {
-      throw new UnauthorizedException();
-    }
-    return true;
-  }
-
-  private extractTokenFromHeader(request: Request & { headers: IncomingHttpHeaders }): string | undefined {
-    const [type, token] = request.headers.authorization?.split(' ') ?? [];
-    return type === 'Bearer' ? token : undefined;
-  }
-}
-
-
+import {
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { PrismaClient, UserRole } from '@prisma/client';
+import { Request } from 'express';
+import { IncomingHttpHeaders } from 'http';
+import { Logger } from '@nestjs/common';
+
+@Injectable()
+export class AuthGuard implements CanActivate {
+  private prisma: PrismaClient;
+  private logger = new Logger(AuthGuard.name);
+
+  constructor(
+    private jwtService: JwtService,
+  ) {
+    this.prisma = new PrismaClient();
+  }
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const request = context.switchToHttp().getRequest();
+    const token = this.extractTokenFromHeader(request);
+    if (!token) {
+      throw new UnauthorizedException();
+    }
+    try {
+      const payload = (await this.jwtService.verifyAsync(token)) as {
+        userId: string;
+      };
+
+      //this.logger.log('payload', payload);
+
+      const user = await this.prisma.user.findUnique({
+        where: { id: payload.userId }
+      });
+
+      //this.logger.log('user', user);
+
+      if (!user) {
+        throw new UnauthorizedException();
+      }
+
+      request['user'] = user;
+    } catch {
+      this.logger.log('UnauthorizedException');
+      throw new UnauthorizedException();
+    }
+    return true;
+  }
+
+  private extractTokenFromHeader(request: Request & { headers: IncomingHttpHeaders }): string | undefined {
+    const [type, token] = request.headers.authorization?.split(' ') ?? [];
+    //this.logger.log('extractTokenFromHeader', {type, token});
+    return type === 'Bearer' ? token : undefined;
+  }
+}
+
+//optional auth guard
+@Injectable()
+export class OptionalAuthGuard implements CanActivate {
+   private prisma: PrismaClient;
+
+  constructor(
+    private jwtService: JwtService,
+  ) {
+    this.prisma = new PrismaClient();
+  }
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const request = context.switchToHttp().getRequest();
+    const token = this.extractTokenFromHeader(request);
+    if (!token) {
+      return true;
+    }
+    try {
+      const payload = (await this.jwtService.verifyAsync(token)) as {
+        userId: string;
+      };
+
+      const user = await this.prisma.user.findUnique({
+        where: { id: payload.userId }
+      });
+
+      if (!user) {
+        throw new UnauthorizedException();
+      }
+
+      request['user'] = user;
+
+      // Continue without setting user
+    } catch {
+      // Continue without setting user
+    }
+    return true;
+  }
+
+  private extractTokenFromHeader(request: Request & { headers: IncomingHttpHeaders }): string | undefined {
+    const [type, token] = request.headers.authorization?.split(' ') ?? [];
+    return type === 'Bearer' ? token : undefined;
+  }
+}
+
+//admin auth guard
+@Injectable()
+export class AdminAuthGuard implements CanActivate {
+  private prisma: PrismaClient;
+
+  constructor(
+    private jwtService: JwtService,
+  ) {
+    this.prisma = new PrismaClient();
+  }
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const request = context.switchToHttp().getRequest();
+    const token = this.extractTokenFromHeader(request);
+    if (!token) {
+      throw new UnauthorizedException();
+    }
+    try {
+      const payload = (await this.jwtService.verifyAsync(token)) as {
+        userId: string;
+      };
+
+      const user = await this.prisma.user.findUnique({
+        where: { id: payload.userId }
+      });
+
+      if (!user) {
+        throw new UnauthorizedException();
+      }
+
+      if(user.role !== UserRole.ADMIN && user.role !== UserRole.SUPER_ADMIN) {
+        throw new UnauthorizedException();
+      }
+
+      request['user'] = user;
+    } catch {
+      throw new UnauthorizedException();
+    }
+    return true;
+  }
+
+  private extractTokenFromHeader(request: Request & { headers: IncomingHttpHeaders }): string | undefined {
+    const [type, token] = request.headers.authorization?.split(' ') ?? [];
+    return type === 'Bearer' ? token : undefined;
+  }
+}
+
+

package/src/auth/auth.module.ts

@@ -1,25 +1,25 @@
-import { Module, DynamicModule, Global } from '@nestjs/common';
-import { JwtModule } from '@nestjs/jwt';
-
-export interface AuthModuleOptions {
-  jwtSecret: string;
-  jwtExpiresIn?: string | number;
-}
-
-@Global()
-@Module({})
-export class AuthModule {
-  static forRoot(options: AuthModuleOptions): DynamicModule {
-    console.log('AuthModule.forRoot', options);
-    return {
-      module: AuthModule,
-      imports: [
-        JwtModule.register({
-          secret: options.jwtSecret,
-          signOptions: { expiresIn: options.jwtExpiresIn || '7d' },
-        }),
-      ],
-      exports: [JwtModule],
-    };
-  }
-}
+import { Module, DynamicModule, Global } from '@nestjs/common';
+import { JwtModule } from '@nestjs/jwt';
+
+export interface AuthModuleOptions {
+  jwtSecret: string;
+  jwtExpiresIn?: string | number;
+}
+
+@Global()
+@Module({})
+export class AuthModule {
+  static forRoot(options: AuthModuleOptions): DynamicModule {
+    console.log('AuthModule.forRoot', options);
+    return {
+      module: AuthModule,
+      imports: [
+        JwtModule.register({
+          secret: options.jwtSecret,
+          signOptions: { expiresIn: options.jwtExpiresIn || '7d' },
+        }),
+      ],
+      exports: [JwtModule],
+    };
+  }
+}

package/src/cache/cache.module.ts

@@ -1,25 +1,25 @@
-import { Module, DynamicModule, Global } from '@nestjs/common';
-import { Cacheable } from 'cacheable';
-import { CacheService } from './cache.service';
-import KeyvRedis from '@keyv/redis';
-
-@Global()
-@Module({})
-export class CacheModule {
-  static forRoot(redisUrl: string): DynamicModule {
-    return {
-      module: CacheModule,
-      providers: [
-        {
-          provide: 'CACHE_INSTANCE',
-          useFactory: () => {
-            const secondary = new KeyvRedis(redisUrl);
-            return new Cacheable({ secondary, ttl: '1h' });
-          },
-        },
-        CacheService,
-      ],
-      exports: ['CACHE_INSTANCE', CacheService],
-    };
-  }
-}
+import { Module, DynamicModule, Global } from '@nestjs/common';
+import { Cacheable } from 'cacheable';
+import { CacheService } from './cache.service';
+import KeyvRedis from '@keyv/redis';
+
+@Global()
+@Module({})
+export class CacheModule {
+  static forRoot(redisUrl: string): DynamicModule {
+    return {
+      module: CacheModule,
+      providers: [
+        {
+          provide: 'CACHE_INSTANCE',
+          useFactory: () => {
+            const secondary = new KeyvRedis(redisUrl);
+            return new Cacheable({ secondary, ttl: '1h' });
+          },
+        },
+        CacheService,
+      ],
+      exports: ['CACHE_INSTANCE', CacheService],
+    };
+  }
+}

package/src/cache/cache.service.ts

@@ -1,19 +1,19 @@
-import { Inject, Injectable } from '@nestjs/common';
-import { Cacheable } from 'cacheable';
-
-@Injectable()
-export class CacheService<T> {
-  constructor(@Inject('CACHE_INSTANCE') private readonly cache: Cacheable) {}
-
-  async get<T>(key: string): Promise<T> {
-    return await this.cache.get(key);
-  }
-
-  async set(key: string, value: T, ttl?: number | string): Promise<void> {
-    await this.cache.set(key, value, ttl);
-  }
-
-  async delete(key: string): Promise<void> {
-    await this.cache.delete(key);
-  }
-}
+import { Inject, Injectable } from '@nestjs/common';
+import { Cacheable } from 'cacheable';
+
+@Injectable()
+export class CacheService<T> {
+  constructor(@Inject('CACHE_INSTANCE') private readonly cache: Cacheable) {}
+
+  async get<T>(key: string): Promise<T> {
+    return await this.cache.get(key);
+  }
+
+  async set(key: string, value: T, ttl?: number | string): Promise<void> {
+    await this.cache.set(key, value, ttl);
+  }
+
+  async delete(key: string): Promise<void> {
+    await this.cache.delete(key);
+  }
+}