feat: streamline schema definitions and enhance service logic

- Refactored package.json to consolidate Jest configuration for improved readability.
- Cleaned up launch.json by removing unnecessary whitespace for better formatting.
- Updated CronService to refine service disabling logic based on recent activity, ensuring more accurate service management.
- Enhanced MeetingRoom and WorkshopMeetingRoom schemas with consistent formatting and improved field descriptions for clarity.
- Improved error handling in MeetingRoom schema to provide clearer feedback for unauthorized access and missing resources.
- Updated pothos.generated.ts to reflect recent schema changes, ensuring type consistency across the application.

These changes enhance the overall structure and maintainability of the codebase, improving service management and user experience.

.vscode/launch.json

@@ -4,7 +4,6 @@
   // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
   "version": "0.2.0",
   "configurations": [
-    
     {
       "name": "Attach by Process ID",
       "processId": "${command:PickProcess}",

package.json

@@ -140,19 +140,13 @@
     "@css-inline/css-inline-linux-x64-musl": "^0.14.3"
   },
   "jest": {
-    "moduleFileExtensions": [
+    "moduleFileExtensions": ["js", "json", "ts"],
-      "js",
-      "json",
-      "ts"
-    ],
     "rootDir": "src",
     "testRegex": ".*\\.spec\\.ts$",
     "transform": {
       "^.+\\.(t|j)s$": "ts-jest"
     },
-    "collectCoverageFrom": [
+    "collectCoverageFrom": ["**/*.(t|j)s"],
-      "**/*.(t|j)s"
-    ],
     "coverageDirectory": "../coverage",
     "testEnvironment": "node"
   },

src/Cron/cron.service.ts

@@ -161,22 +161,30 @@ export class CronService {
   async taskDisableServiceWithoutSchedule() {
     const services = await this.prisma.service.findMany({
       where: {
-        NOT: {
+        status: ServiceStatus.APPROVED,
-          // check if service has any schedule in the past 30 days
+        AND: [
-          managedService: {
+          {
-            some: {
+            managedService: {
-              schedule: {
+              none: {
-                some: {
+                schedule: {
-                  scheduleStart: { gte: DateTimeUtils.now().minus({ days: 30 }).toJSDate() },
+                  some: {
+                    scheduleStart: {
+                      gte: DateTimeUtils.now().minus({ minutes: 10 }).toJSDate(),
+                    },
+                  },
                 },
               },
             },
           },
-          // and createdAt is more than 3 days ago
+          {
-          createdAt: {
+            createdAt: {
-            lt: DateTimeUtils.now().minus({ days: 3 }).toJSDate(),
+              lt: DateTimeUtils.now().minus({ days: 3 }).toJSDate(),
+            },
           },
-        },
+        ],
+      },
+      include: {
+        managedService: true,
       },
     })
 
@@ -187,7 +195,10 @@ export class CronService {
           status: ServiceStatus.INACTIVE,
         },
       })
-      Logger.log(`Service ${service.id} has been disabled`, 'CronService')
+      Logger.log(
+        `Service ${service.id} has been disabled due to inactivity. Managed Services: ${service.managedService.length}`,
+        'CronService',
+      )
     }
   }
 

src/MeetingRoom/meetingroom.schema.ts

@@ -1,72 +1,67 @@
-import { Inject, Injectable, Logger } from "@nestjs/common";
+import { Inject, Injectable, Logger } from '@nestjs/common'
-import {
+import { Pothos, PothosRef, PothosSchema, SchemaBuilderToken } from '@smatch-corp/nestjs-pothos'
-  Pothos,
+import { Builder, SchemaContext } from 'src/Graphql/graphql.builder'
-  PothosRef,
+import { LiveKitService } from 'src/LiveKit/livekit.service'
-  PothosSchema,
+import { MinioService } from 'src/Minio/minio.service'
-  SchemaBuilderToken,
+import { PrismaService } from 'src/Prisma/prisma.service'
-} from "@smatch-corp/nestjs-pothos";
-import { Builder, SchemaContext } from "src/Graphql/graphql.builder";
-import { LiveKitService } from "src/LiveKit/livekit.service";
-import { MinioService } from "src/Minio/minio.service";
-import { PrismaService } from "src/Prisma/prisma.service";
 @Injectable()
 export class MeetingRoomSchema extends PothosSchema {
   constructor(
     @Inject(SchemaBuilderToken) private readonly builder: Builder,
     private readonly prisma: PrismaService,
     private readonly livekitService: LiveKitService,
-    private readonly minioService: MinioService
+    private readonly minioService: MinioService,
   ) {
-    super();
+    super()
   }
   @PothosRef()
   meetingRoom() {
-    return this.builder.prismaObject("MeetingRoom", {
+    return this.builder.prismaObject('MeetingRoom', {
       fields: (t) => ({
-        id: t.exposeID("id"),
+        id: t.exposeID('id'),
-        collaborationSessionId: t.exposeString("collaborationSessionId"),
+        collaborationSessionId: t.exposeString('collaborationSessionId'),
-        collaborationSession: t.relation("collaborationSession"),
+        collaborationSession: t.relation('collaborationSession'),
-        collaborators: t.relation("collaborators"),
+        collaborators: t.relation('collaborators'),
-        createdAt: t.expose("createdAt", { type: "DateTime" }),
+        createdAt: t.expose('createdAt', { type: 'DateTime' }),
-        updatedAt: t.expose("updatedAt", { type: "DateTime" }),
+        updatedAt: t.expose('updatedAt', { type: 'DateTime' }),
         recordUrl: t.string({
           nullable: true,
           resolve: async (meetingRoom) => {
-            return await this.minioService.getRoomRecordUrl(meetingRoom.id);
+            return await this.minioService.getRoomRecordUrl(meetingRoom.id)
           },
         }),
       }),
-    });
+    })
   }
 
   @PothosRef()
   meetingRoomJoinInfo() {
-    return this.builder.simpleObject("MeetingRoomJoinInfo", {
+    return this.builder.simpleObject('MeetingRoomJoinInfo', {
       fields: (t) => ({
         id: t.string({
-          description: "The ID of the meeting room.",
+          description: 'The ID of the meeting room.',
         }),
         token: t.string({
-          description: "The token to join the meeting room.",
+          description: 'The token to join the meeting room.',
         }),
         serverUrl: t.string({
-          description: "The URL of the server.",
+          description: 'The URL of the server.',
         }),
       }),
-    });
+    })
   }
 
   @PothosRef()
   meetingRoomCollaborator() {
-    return this.builder.prismaObject("MeetingRoomCollaborator", {
+    return this.builder.prismaObject('MeetingRoomCollaborator', {
       fields: (t) => ({
-        id: t.exposeID("id"),
+        id: t.exposeID('id'),
-        meetingRoomId: t.exposeString("meetingRoomId"),
+        meetingRoomId: t.exposeString('meetingRoomId'),
-        meetingRoom: t.relation("meetingRoom"),
+        meetingRoom: t.relation('meetingRoom'),
-        userId: t.exposeString("userId"),
+        userId: t.exposeString('userId'),
-        user: t.relation("user"),
+        user: t.relation('user'),
       }),
-    });
+    })
   }
 
   @Pothos()
@@ -82,30 +77,29 @@ export class MeetingRoomSchema extends PothosSchema {
         },
         resolve: async (_query, _parent, args, ctx: SchemaContext) => {
           if (ctx.isSubscription) {
-            throw new Error("Not allowed");
+            throw new Error('Not allowed')
           }
-          const collaborationSession =
+          const collaborationSession = await this.prisma.collaborationSession.findUnique({
-            await this.prisma.collaborationSession.findUnique({
+            where: {
-              where: {
+              scheduleDateId: args.scheduleDateId,
-                scheduleDateId: args.scheduleDateId,
+            },
-              },
+          })
-            });
           if (!collaborationSession) {
-            throw new Error("Collaboration session not found");
+            throw new Error('Collaboration session not found')
           }
           const meetingRoom = await this.prisma.meetingRoom.findUnique({
             where: {
               collaborationSessionId: collaborationSession.id,
             },
-          });
+          })
           if (meetingRoom) {
-            return meetingRoom;
+            return meetingRoom
           }
           return await this.prisma.meetingRoom.create({
             data: {
               collaborationSessionId: collaborationSession.id,
             },
-          });
+          })
         },
       }),
       // get meeting room info by room id and check if user is collaborator of collaboration session then create new token and return it,
@@ -119,38 +113,34 @@ export class MeetingRoomSchema extends PothosSchema {
         },
         resolve: async (_, args, ctx: SchemaContext) => {
           if (ctx.isSubscription) {
-            throw new Error("Not allowed");
+            throw new Error('Not allowed')
           }
           if (!ctx.http.me) {
-            throw new Error("Unauthorized");
+            throw new Error('Unauthorized')
           }
           const meetingRoom = await this.prisma.meetingRoom.findUnique({
             where: { collaborationSessionId: args.collaborationSessionId },
-          });
+          })
           if (!meetingRoom) {
-            throw new Error("Meeting room not found");
+            throw new Error('Meeting room not found')
           }
           // check if user is collaborator of collaboration session
-          const collaborationSession =
+          const collaborationSession = await this.prisma.collaborationSession.findUnique({
-            await this.prisma.collaborationSession.findUnique({
+            where: { id: meetingRoom.collaborationSessionId },
-              where: { id: meetingRoom.collaborationSessionId },
+          })
-            });
           if (!collaborationSession) {
-            throw new Error("Collaboration session not found");
+            throw new Error('Collaboration session not found')
           }
           if (!collaborationSession.collaboratorsIds.includes(ctx.http.me.id)) {
-            throw new Error("User is not collaborator");
+            throw new Error('User is not collaborator')
           }
           // create new token
-          const token = await this.livekitService.createToken(
+          const token = await this.livekitService.createToken(ctx.http.me, meetingRoom.id)
-            ctx.http.me,
-            meetingRoom.id
-          );
           return {
             id: meetingRoom.id,
             token,
             serverUrl: this.livekitService.getServerUrl(),
-          };
+          }
         },
       }),
       interviewJoinInfo: t.field({
@@ -162,48 +152,45 @@ export class MeetingRoomSchema extends PothosSchema {
         },
         resolve: async (_, args, ctx: SchemaContext) => {
           if (ctx.isSubscription) {
-            throw new Error("Not allowed");
+            throw new Error('Not allowed')
           }
           if (!ctx.http.me) {
-            throw new Error("Unauthorized");
+            throw new Error('Unauthorized')
           }
-          const token = await this.livekitService.createToken(
+          const token = await this.livekitService.createToken(ctx.http.me, args.scheduleId)
-            ctx.http.me,
-            args.scheduleId
-          );
           return {
             id: args.scheduleId,
             token,
             serverUrl: this.livekitService.getServerUrl(),
-          };
+          }
         },
       }),
-    }));
+    }))
     this.builder.mutationFields((t) => ({
       createMeetingRoom: t.prismaField({
         type: this.meetingRoom(),
         args: {
           input: t.arg({
-            type: this.builder.generator.getCreateInput("MeetingRoom", [
+            type: this.builder.generator.getCreateInput('MeetingRoom', [
-              "id",
+              'id',
-              "createdAt",
+              'createdAt',
-              "updatedAt",
+              'updatedAt',
-              "collaborators",
+              'collaborators',
             ]),
             required: true,
           }),
         },
         resolve: async (query, _parent, args, ctx: SchemaContext) => {
           if (ctx.isSubscription) {
-            throw new Error("Not allowed");
+            throw new Error('Not allowed')
           }
           if (!ctx.http.me) {
-            throw new Error("Unauthorized");
+            throw new Error('Unauthorized')
           }
           return await this.prisma.meetingRoom.create({
             ...query,
             data: args.input,
-          });
+          })
         },
       }),
       updateMeetingRoomCollaborators: t.prismaField({
@@ -221,10 +208,10 @@ export class MeetingRoomSchema extends PothosSchema {
         },
         resolve: async (query, _parent, args, ctx: SchemaContext) => {
           if (ctx.isSubscription) {
-            throw new Error("Not allowed");
+            throw new Error('Not allowed')
           }
           if (!ctx.http.me) {
-            throw new Error("Unauthorized");
+            throw new Error('Unauthorized')
           }
           return await this.prisma.meetingRoom.update({
             ...query,
@@ -234,9 +221,7 @@ export class MeetingRoomSchema extends PothosSchema {
             data: {
               collaborators: {
                 createMany: {
-                  data: args.addCollaborators
+                  data: args.addCollaborators ? args.addCollaborators.map((id) => ({ userId: id })) : [],
-                    ? args.addCollaborators.map((id) => ({ userId: id }))
-                    : [],
                 },
                 deleteMany: {
                   userId: {
@@ -245,9 +230,9 @@ export class MeetingRoomSchema extends PothosSchema {
                 },
               },
             },
-          });
+          })
         },
       }),
-    }));
+    }))
   }
 }

src/Message/message.schema.ts

@@ -176,7 +176,7 @@ export class MessageSchema extends PothosSchema {
               data: {
                 ...args.input,
                 context: MessageContextType.CHAT,
-              }
+              },
             })
             await tx.chatRoom.update({
               where: {

src/WorkshopMeetingRoom/workshopmeetingroom.schema.ts

@@ -1,58 +1,53 @@
-import { Inject, Injectable } from "@nestjs/common";
+import { Inject, Injectable } from '@nestjs/common'
-import { ChatRoomType } from "@prisma/client";
+import { ChatRoomType } from '@prisma/client'
-import {
+import { Pothos, PothosRef, PothosSchema, SchemaBuilderToken } from '@smatch-corp/nestjs-pothos'
-  Pothos,
+import { Builder } from '../Graphql/graphql.builder'
-  PothosRef,
+import { LiveKitService } from '../LiveKit/livekit.service'
-  PothosSchema,
+import { PrismaService } from '../Prisma/prisma.service'
-  SchemaBuilderToken,
-} from "@smatch-corp/nestjs-pothos";
-import { Builder } from "../Graphql/graphql.builder";
-import { LiveKitService } from "../LiveKit/livekit.service";
-import { PrismaService } from "../Prisma/prisma.service";
 @Injectable()
 export class WorkshopMeetingRoomSchema extends PothosSchema {
   constructor(
     @Inject(SchemaBuilderToken) private readonly builder: Builder,
     private readonly prisma: PrismaService,
-    private readonly livekitService: LiveKitService
+    private readonly livekitService: LiveKitService,
   ) {
-    super();
+    super()
   }
 
   @PothosRef()
   workshopMeetingRoom() {
-    return this.builder.prismaObject("WorkshopMeetingRoom", {
+    return this.builder.prismaObject('WorkshopMeetingRoom', {
       fields: (t) => ({
-        id: t.exposeID("id", {
+        id: t.exposeID('id', {
-          description: "The ID of the workshop meeting room.",
+          description: 'The ID of the workshop meeting room.',
         }),
-        workshopId: t.exposeID("workshopId", {
+        workshopId: t.exposeID('workshopId', {
-          description: "The ID of the workshop that the meeting room is for.",
+          description: 'The ID of the workshop that the meeting room is for.',
         }),
-        workshop: t.relation("workshop", {
+        workshop: t.relation('workshop', {
-          description: "The workshop that the meeting room is for.",
+          description: 'The workshop that the meeting room is for.',
         }),
       }),
-    });
+    })
   }
   @PothosRef()
   workshopMeetingRoomJoinInfo() {
-    return this.builder.simpleObject("WorkshopMeetingRoomJoinInfo", {
+    return this.builder.simpleObject('WorkshopMeetingRoomJoinInfo', {
       fields: (t) => ({
         id: t.string({
-          description: "The ID of the workshop meeting room.",
+          description: 'The ID of the workshop meeting room.',
         }),
         token: t.string({
-          description: "The token to join the workshop meeting room.",
+          description: 'The token to join the workshop meeting room.',
         }),
         serverUrl: t.string({
-          description: "The URL of the server.",
+          description: 'The URL of the server.',
         }),
         chatRoomId: t.string({
-          description: "The ID of the chat room.",
+          description: 'The ID of the chat room.',
         }),
       }),
-    });
+    })
   }
 
   @Pothos()
@@ -60,59 +55,56 @@ export class WorkshopMeetingRoomSchema extends PothosSchema {
     this.builder.queryFields((t) => ({
       workshopMeetingRoom: t.prismaField({
         type: this.workshopMeetingRoom(),
-        args: this.builder.generator.findUniqueArgs("WorkshopMeetingRoom"),
+        args: this.builder.generator.findUniqueArgs('WorkshopMeetingRoom'),
         resolve: async (query, _root, args, _ctx, _info) => {
           return await this.prisma.workshopMeetingRoom.findUnique({
             ...query,
             where: args.where,
-          });
+          })
         },
       }),
       workshopMeetingRoomJoinInfo: t.field({
         type: this.workshopMeetingRoomJoinInfo(),
         args: {
           workshopId: t.arg({
-            type: "String",
+            type: 'String',
             required: true,
           }),
         },
         resolve: async (_, args, ctx) => {
           if (ctx.isSubscription) {
-            throw new Error("Not allowed");
+            throw new Error('Not allowed')
           }
           if (!ctx.http?.me) {
-            throw new Error("Unauthorized");
+            throw new Error('Unauthorized')
           }
           const meetingRoom = await this.prisma.workshopMeetingRoom.findUnique({
             where: {
               workshopId: args.workshopId,
             },
-          });
+          })
           // query chat room
           const chatRoom = await this.prisma.chatRoom.findFirst({
             where: {
               workshopId: args.workshopId,
               type: ChatRoomType.WORKSHOP,
             },
-          });
+          })
           if (!meetingRoom) {
-            throw new Error("Meeting room not found");
+            throw new Error('Meeting room not found')
           }
-          const serverUrl = this.livekitService.getServerUrl();
+          const serverUrl = this.livekitService.getServerUrl()
           return {
             id: meetingRoom.id,
-            token: await this.livekitService.createToken(
+            token: await this.livekitService.createToken(ctx.http?.me, meetingRoom.id),
-              ctx.http?.me,
-              meetingRoom.id
-            ),
             serverUrl,
             chatRoomId: chatRoom?.id,
-          };
+          }
         },
       }),
       workshopMeetingRooms: t.prismaField({
         type: [this.workshopMeetingRoom()],
-        args: this.builder.generator.findManyArgs("WorkshopMeetingRoom"),
+        args: this.builder.generator.findManyArgs('WorkshopMeetingRoom'),
         resolve: async (query, _root, args, _ctx, _info) => {
           return await this.prisma.workshopMeetingRoom.findMany({
             ...query,
@@ -121,9 +113,9 @@ export class WorkshopMeetingRoomSchema extends PothosSchema {
             cursor: args.cursor ?? undefined,
             take: args.take ?? undefined,
             skip: args.skip ?? undefined,
-          });
+          })
         },
       }),
-    }));
+    }))
   }
 }