Refactor code structure and dependencies

src/generated/graphql.ts

@@ -0,0 +1,324 @@
+import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
+export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
+export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: { input: string; output: string; }
+  String: { input: string; output: string; }
+  Boolean: { input: boolean; output: boolean; }
+  Int: { input: number; output: number; }
+  Float: { input: number; output: number; }
+  DateTime: { input: any; output: any; }
+};
+
+export type Center = {
+  __typename?: 'Center';
+  id?: Maybe<Scalars['ID']['output']>;
+  userId?: Maybe<Scalars['ID']['output']>;
+};
+
+export type CenterStaff = {
+  __typename?: 'CenterStaff';
+  centerId?: Maybe<Scalars['ID']['output']>;
+  serviceId?: Maybe<Scalars['ID']['output']>;
+  staffId?: Maybe<Scalars['ID']['output']>;
+};
+
+export type ChatRoom = {
+  __typename?: 'ChatRoom';
+  id?: Maybe<Scalars['ID']['output']>;
+};
+
+export type Order = {
+  __typename?: 'Order';
+  id?: Maybe<Scalars['ID']['output']>;
+  userId?: Maybe<Scalars['ID']['output']>;
+};
+
+export type Query = {
+  __typename?: 'Query';
+  users?: Maybe<Array<User>>;
+};
+
+export type Service = {
+  __typename?: 'Service';
+  id?: Maybe<Scalars['ID']['output']>;
+  userId?: Maybe<Scalars['ID']['output']>;
+};
+
+export type ServiceFeedback = {
+  __typename?: 'ServiceFeedback';
+  id?: Maybe<Scalars['ID']['output']>;
+  userId?: Maybe<Scalars['ID']['output']>;
+};
+
+export type User = {
+  __typename?: 'User';
+  CenterStaff?: Maybe<CenterStaff>;
+  Service?: Maybe<Array<Service>>;
+  WorkshopSubscription?: Maybe<Array<WorkshopSubscription>>;
+  center?: Maybe<Center>;
+  centerStaffChatRoom?: Maybe<Array<ChatRoom>>;
+  createdAt?: Maybe<Scalars['DateTime']['output']>;
+  customerChatRoom?: Maybe<Array<ChatRoom>>;
+  documents?: Maybe<Array<Documents>>;
+  email?: Maybe<Scalars['String']['output']>;
+  id?: Maybe<Scalars['ID']['output']>;
+  name?: Maybe<Scalars['String']['output']>;
+  order?: Maybe<Array<Order>>;
+  phoneNumber?: Maybe<Scalars['String']['output']>;
+  role?: Maybe<Scalars['String']['output']>;
+  sendingMessage?: Maybe<Array<SendingMessage>>;
+  serviceFeedbacks?: Maybe<Array<ServiceFeedback>>;
+  updatedAt?: Maybe<Scalars['DateTime']['output']>;
+};
+
+export type Workshop = {
+  __typename?: 'Workshop';
+  id?: Maybe<Scalars['ID']['output']>;
+};
+
+export type WorkshopSubscription = {
+  __typename?: 'WorkshopSubscription';
+  user?: Maybe<User>;
+  userId?: Maybe<Scalars['ID']['output']>;
+  workshop?: Maybe<Workshop>;
+  workshopId?: Maybe<Scalars['ID']['output']>;
+};
+
+export type Documents = {
+  __typename?: 'documents';
+  id?: Maybe<Scalars['ID']['output']>;
+  userId?: Maybe<Scalars['ID']['output']>;
+};
+
+export type SendingMessage = {
+  __typename?: 'sendingMessage';
+  id?: Maybe<Scalars['ID']['output']>;
+  userId?: Maybe<Scalars['ID']['output']>;
+};
+
+
+
+export type ResolverTypeWrapper<T> = Promise<T> | T;
+
+
+export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
+  resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
+};
+export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs>;
+
+export type ResolverFn<TResult, TParent, TContext, TArgs> = (
+  parent: TParent,
+  args: TArgs,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => Promise<TResult> | TResult;
+
+export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
+  parent: TParent,
+  args: TArgs,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;
+
+export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (
+  parent: TParent,
+  args: TArgs,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => TResult | Promise<TResult>;
+
+export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
+  subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>;
+  resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>;
+}
+
+export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
+  subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
+  resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
+}
+
+export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> =
+  | SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
+  | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
+
+export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> =
+  | ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
+  | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
+
+export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
+  parent: TParent,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
+
+export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
+
+export type NextResolverFn<T> = () => Promise<T>;
+
+export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (
+  next: NextResolverFn<TResult>,
+  parent: TParent,
+  args: TArgs,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => TResult | Promise<TResult>;
+
+
+
+/** Mapping between all available schema types and the resolvers types */
+export type ResolversTypes = {
+  Boolean: ResolverTypeWrapper<Scalars['Boolean']['output']>;
+  Center: ResolverTypeWrapper<Center>;
+  CenterStaff: ResolverTypeWrapper<CenterStaff>;
+  ChatRoom: ResolverTypeWrapper<ChatRoom>;
+  DateTime: ResolverTypeWrapper<Scalars['DateTime']['output']>;
+  Float: ResolverTypeWrapper<Scalars['Float']['output']>;
+  ID: ResolverTypeWrapper<Scalars['ID']['output']>;
+  Int: ResolverTypeWrapper<Scalars['Int']['output']>;
+  Order: ResolverTypeWrapper<Order>;
+  Query: ResolverTypeWrapper<{}>;
+  Service: ResolverTypeWrapper<Service>;
+  ServiceFeedback: ResolverTypeWrapper<ServiceFeedback>;
+  String: ResolverTypeWrapper<Scalars['String']['output']>;
+  User: ResolverTypeWrapper<User>;
+  Workshop: ResolverTypeWrapper<Workshop>;
+  WorkshopSubscription: ResolverTypeWrapper<WorkshopSubscription>;
+  documents: ResolverTypeWrapper<Documents>;
+  sendingMessage: ResolverTypeWrapper<SendingMessage>;
+};
+
+/** Mapping between all available schema types and the resolvers parents */
+export type ResolversParentTypes = {
+  Boolean: Scalars['Boolean']['output'];
+  Center: Center;
+  CenterStaff: CenterStaff;
+  ChatRoom: ChatRoom;
+  DateTime: Scalars['DateTime']['output'];
+  Float: Scalars['Float']['output'];
+  ID: Scalars['ID']['output'];
+  Int: Scalars['Int']['output'];
+  Order: Order;
+  Query: {};
+  Service: Service;
+  ServiceFeedback: ServiceFeedback;
+  String: Scalars['String']['output'];
+  User: User;
+  Workshop: Workshop;
+  WorkshopSubscription: WorkshopSubscription;
+  documents: Documents;
+  sendingMessage: SendingMessage;
+};
+
+export type CenterResolvers<ContextType = any, ParentType extends ResolversParentTypes['Center'] = ResolversParentTypes['Center']> = {
+  id?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  userId?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type CenterStaffResolvers<ContextType = any, ParentType extends ResolversParentTypes['CenterStaff'] = ResolversParentTypes['CenterStaff']> = {
+  centerId?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  serviceId?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  staffId?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type ChatRoomResolvers<ContextType = any, ParentType extends ResolversParentTypes['ChatRoom'] = ResolversParentTypes['ChatRoom']> = {
+  id?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export interface DateTimeScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['DateTime'], any> {
+  name: 'DateTime';
+}
+
+export type OrderResolvers<ContextType = any, ParentType extends ResolversParentTypes['Order'] = ResolversParentTypes['Order']> = {
+  id?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  userId?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type QueryResolvers<ContextType = any, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = {
+  users?: Resolver<Maybe<Array<ResolversTypes['User']>>, ParentType, ContextType>;
+};
+
+export type ServiceResolvers<ContextType = any, ParentType extends ResolversParentTypes['Service'] = ResolversParentTypes['Service']> = {
+  id?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  userId?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type ServiceFeedbackResolvers<ContextType = any, ParentType extends ResolversParentTypes['ServiceFeedback'] = ResolversParentTypes['ServiceFeedback']> = {
+  id?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  userId?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type UserResolvers<ContextType = any, ParentType extends ResolversParentTypes['User'] = ResolversParentTypes['User']> = {
+  CenterStaff?: Resolver<Maybe<ResolversTypes['CenterStaff']>, ParentType, ContextType>;
+  Service?: Resolver<Maybe<Array<ResolversTypes['Service']>>, ParentType, ContextType>;
+  WorkshopSubscription?: Resolver<Maybe<Array<ResolversTypes['WorkshopSubscription']>>, ParentType, ContextType>;
+  center?: Resolver<Maybe<ResolversTypes['Center']>, ParentType, ContextType>;
+  centerStaffChatRoom?: Resolver<Maybe<Array<ResolversTypes['ChatRoom']>>, ParentType, ContextType>;
+  createdAt?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
+  customerChatRoom?: Resolver<Maybe<Array<ResolversTypes['ChatRoom']>>, ParentType, ContextType>;
+  documents?: Resolver<Maybe<Array<ResolversTypes['documents']>>, ParentType, ContextType>;
+  email?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  id?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  order?: Resolver<Maybe<Array<ResolversTypes['Order']>>, ParentType, ContextType>;
+  phoneNumber?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  role?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  sendingMessage?: Resolver<Maybe<Array<ResolversTypes['sendingMessage']>>, ParentType, ContextType>;
+  serviceFeedbacks?: Resolver<Maybe<Array<ResolversTypes['ServiceFeedback']>>, ParentType, ContextType>;
+  updatedAt?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type WorkshopResolvers<ContextType = any, ParentType extends ResolversParentTypes['Workshop'] = ResolversParentTypes['Workshop']> = {
+  id?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type WorkshopSubscriptionResolvers<ContextType = any, ParentType extends ResolversParentTypes['WorkshopSubscription'] = ResolversParentTypes['WorkshopSubscription']> = {
+  user?: Resolver<Maybe<ResolversTypes['User']>, ParentType, ContextType>;
+  userId?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  workshop?: Resolver<Maybe<ResolversTypes['Workshop']>, ParentType, ContextType>;
+  workshopId?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type DocumentsResolvers<ContextType = any, ParentType extends ResolversParentTypes['documents'] = ResolversParentTypes['documents']> = {
+  id?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  userId?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type SendingMessageResolvers<ContextType = any, ParentType extends ResolversParentTypes['sendingMessage'] = ResolversParentTypes['sendingMessage']> = {
+  id?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  userId?: Resolver<Maybe<ResolversTypes['ID']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type Resolvers<ContextType = any> = {
+  Center?: CenterResolvers<ContextType>;
+  CenterStaff?: CenterStaffResolvers<ContextType>;
+  ChatRoom?: ChatRoomResolvers<ContextType>;
+  DateTime?: GraphQLScalarType;
+  Order?: OrderResolvers<ContextType>;
+  Query?: QueryResolvers<ContextType>;
+  Service?: ServiceResolvers<ContextType>;
+  ServiceFeedback?: ServiceFeedbackResolvers<ContextType>;
+  User?: UserResolvers<ContextType>;
+  Workshop?: WorkshopResolvers<ContextType>;
+  WorkshopSubscription?: WorkshopSubscriptionResolvers<ContextType>;
+  documents?: DocumentsResolvers<ContextType>;
+  sendingMessage?: SendingMessageResolvers<ContextType>;
+};
+

src/graphql/graphql.module.ts

@@ -1,8 +1,9 @@
-import { Module } from '@nestjs/common';
+import { MiddlewareConsumer, Module } from '@nestjs/common';
 import { GraphQLModule } from '@nestjs/graphql';
 import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
 import { PrismaService } from '../prisma/prisma.service';
 import { schema } from './schema';
+import { GraphQLValidationMiddleware } from 'src/middlewares/graphql.middleware';
 @Module({
   imports: [
     GraphQLModule.forRoot<ApolloDriverConfig>({
@@ -15,4 +16,10 @@ import { schema } from './schema';
   ],
   providers: [PrismaService],
 })
-export class GraphqlModule {}
+export class GraphqlModule {
+  configure(consumer: MiddlewareConsumer) {
+    consumer
+      .apply(GraphQLValidationMiddleware) // Apply the custom middleware
+      .forRoutes('graphql'); // Ensure it only applies to the /graphql endpoint
+  }
+}

src/graphql/schema.ts

@@ -1,5 +1,4 @@
 import { builder, prisma } from './graphql.builder';
-import type PrismaTypes from '@pothos/plugin-prisma/generated';
 
 builder.prismaObject('User', {
   fields: (t) => ({
@@ -114,10 +113,103 @@ builder.queryType({
         });
       },
     }),
+    user: t.prismaField({
+      type: 'User',
+      args: {
+        id: t.arg.string(),
+      },
+      resolve: (query, root, args, ctx, info) => {
+        return prisma.user.findUnique({
+          where: {
+            id: args.id?.toString(),
+          },
+        });
+      },
+    }),
+    orders: t.prismaField({
+      type: ['Order'],
+      resolve: (query, root, args, ctx, info) => {
+        return prisma.order.findMany({
+          ...query,
+        });
+      },
+    }),
+    serviceFeedbacks: t.prismaField({
+      type: ['ServiceFeedback'],
+      resolve: (query, root, args, ctx, info) => {
+        return prisma.serviceFeedback.findMany({
+          ...query,
+        });
+      },
+    }),
+    documents: t.prismaField({
+      type: ['UploadedDocument'],
+      resolve: (query, root, args, ctx, info) => {
+        return prisma.uploadedDocument.findMany({
+          ...query,
+        });
+      },
+    }),
+    messages: t.prismaField({
+      type: ['Message'],
+      resolve: (query, root, args, ctx, info) => {
+        return prisma.message.findMany({
+          ...query,
+        });
+      },
+    }),
+    services: t.prismaField({
+      type: ['Service'],
+      resolve: (query, root, args, ctx, info) => {
+        return prisma.service.findMany({
+          ...query,
+        });
+      },
+    }),
+    centers: t.prismaField({
+      type: ['Center'],
+      resolve: (query, root, args, ctx, info) => {
+        return prisma.center.findMany({
+          ...query,
+        });
+      },
+    }),
+    chatRooms: t.prismaField({
+      type: ['ChatRoom'],
+      resolve: (query, root, args, ctx, info) => {
+        return prisma.chatRoom.findMany({
+          ...query,
+        });
+      },
+    }),
+    centerStaffs: t.prismaField({
+      type: ['CenterStaff'],
+      resolve: (query, root, args, ctx, info) => {
+        return prisma.centerStaff.findMany({
+          ...query,
+        });
+      },
+    }),
+    workshopSubscriptions: t.prismaField({
+      type: ['WorkshopSubscription'],
+      resolve: (query, root, args, ctx, info) => {
+        return prisma.workshopSubscription.findMany({
+          ...query,
+        });
+      },
+    }),
+    workshops: t.prismaField({
+      type: ['Workshop'],
+      resolve: (query, root, args, ctx, info) => {
+        return prisma.workshop.findMany({
+          ...query,
+        });
+      },
+    }),
   }),
 });
 
-// // Mutation section
+// Mutation section
 // builder.mutationType({
 //   fields: (t) => ({
 //     createUser: t.prismaField({

src/middlewares/graphql.middleware.ts

@@ -0,0 +1,26 @@
+import { Injectable, NestMiddleware } from '@nestjs/common';
+import { Request, Response, NextFunction } from 'express';
+
+@Injectable()
+export class GraphQLValidationMiddleware implements NestMiddleware {
+  use(req: Request, res: Response, next: NextFunction) {
+    // Only handle POST requests
+    if (req.method === 'POST' && req.headers['content-type'] === 'application/json') {
+      const { query, mutation, subscription } = req.body;
+
+      // If none of these are present, return a custom error response
+      if (!query && !mutation && !subscription) {
+        return res.status(400).json({
+          errors: [
+            {
+              message: 'Must provide a valid GraphQL query, mutation, or subscription.',
+            },
+          ],
+        });
+      }
+    }
+
+    // Continue to the next middleware or GraphQL handler
+    next();
+  }
+}