big gift

src/Graphql/graphql.builder.ts

@@ -13,6 +13,11 @@ import GraphQLUpload from 'graphql-upload/GraphQLUpload.js';
 import type { FileUpload } from 'graphql-upload/processRequest.js';
 import { PrismaCrudGenerator } from './graphql.generator';
 import { PubSub } from 'graphql-subscriptions';
+import SimpleObjectPlugin from '@pothos/plugin-simple-objects';
+import SmartSubscriptionPlugin, {
+  subscribeOptionsFromIterator,
+} from '@pothos/plugin-smart-subscriptions';
+import RelayPlugin from '@pothos/plugin-relay';
 export interface SchemaContext {
   req: Request;
   res: Response;
@@ -24,6 +29,9 @@ export interface SchemaBuilderOption {
   Context: SchemaContext;
   PrismaTypes: PrismaTypes;
   DataModel: PothosPrismaDatamodel;
+  Connection: {
+    totalCount: number | (() => number | Promise<number>);
+  };
   Scalars: {
     DateTime: {
       Input: Date;
@@ -46,7 +54,20 @@ export class Builder extends SchemaBuilder<SchemaBuilderOption> {
 
   constructor(private readonly prisma: PrismaClient) {
     super({
-      plugins: [PrismaPlugin, PrismaUtils],
+      plugins: [
+        PrismaPlugin,
+        PrismaUtils,
+        SimpleObjectPlugin,
+        SmartSubscriptionPlugin,
+        RelayPlugin,
+      ],
+      smartSubscriptions: {
+        debounceDelay: 1000,
+        ...subscribeOptionsFromIterator((name, { pubSub }) => {
+          return pubSub.asyncIterator(name);
+        }),
+      },
+      relay: {},
       prisma: {
         client: prisma,
         exposeDescriptions: true,
@@ -62,6 +83,19 @@ export class Builder extends SchemaBuilder<SchemaBuilderOption> {
 
     this.queryType({});
     this.mutationType({});
+    // this.subscriptionType({});
+
+    this.globalConnectionField('totalCount', (t) =>
+      t.int({
+        nullable: true,
+        resolve: (parent) =>
+          typeof parent.totalCount === 'function'
+            ? parent.totalCount()
+            : parent.totalCount,
+      }),
+    );
+
+    // test print ManagedServiceWhereUniqueInput
   }
 }
 export type BuilderTypes =

src/ManagedService/managedservice.schema.ts

@@ -63,7 +63,8 @@ export class ManagedServiceSchema extends PothosSchema {
     }));
 
     this.builder.mutationFields((t) => ({
-      createManagedService: t.field({
+      createManagedService: t.prismaField({
+        description: 'Create a new managed service.',
         type: this.managedService(),
         args: {
           input: t.arg({
@@ -72,8 +73,9 @@ export class ManagedServiceSchema extends PothosSchema {
             description: 'The data for the managed service.',
           }),
         },
-        resolve: async (parent, args, context) => {
-          return this.prisma.managedService.create({
+        resolve: async (query, root, args, ctx, info) => {
+          return await this.prisma.managedService.create({
+            ...query,
             data: args.input,
           });
         },

src/Milestone/milestone.schema.ts

@@ -63,6 +63,7 @@ export class MilestoneSchema extends PothosSchema {
             ...query,
             skip: args.skip ?? 0,
             take: args.take ?? 10,
+            cursor: args.cursor ?? undefined,
             orderBy: args.orderBy ?? undefined,
             where: args.filter ?? undefined,
           });

src/Service/service.schema.ts

@@ -41,7 +41,9 @@ export class ServiceSchema extends PothosSchema {
         price: t.exposeFloat('price', {
           description: 'The price of the service.',
         }),
-        rating: t.exposeFloat('rating', {
+        rating: t.expose('rating', {
+          type: 'Float',
+          nullable: true,
           description: 'The rating of the service.',
         }),
         imageFile: t.relation('imageFile', {
@@ -100,6 +102,25 @@ export class ServiceSchema extends PothosSchema {
   @Pothos()
   init() {
     this.builder.queryFields((t) => ({
+      testServices: t.prismaConnection(
+        {
+          description: 'A test connection for services',
+          type: this.service(),
+          cursor: 'id',
+          args: this.builder.generator.findManyArgs('Service'),
+          resolve: async (query, root, args, ctx, info) => {
+            return await this.prisma.service.findMany({
+              ...query,
+            });
+          },
+          totalCount: (query) => {
+            return this.prisma.service.count({
+              ...query,
+            });
+          },
+        },
+        {},
+      ),
       services: t.prismaField({
         description:
           'Retrieve a list of services with optional filtering, ordering, and pagination.',
@@ -129,6 +150,9 @@ export class ServiceSchema extends PothosSchema {
           return await this.prisma.service.findUnique({
             ...query,
             where: args.input,
+            include: {
+              feedbacks: true,
+            },
           });
         },
       }),
@@ -147,6 +171,7 @@ export class ServiceSchema extends PothosSchema {
         },
         resolve: async (query, root, args, ctx, info) => {
           return await this.prisma.service.create({
+            ...query,
             data: args.input,
           });
         },

src/generated/graphql.ts

@@ -1,481 +0,0 @@
-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>;
-};