epess-web-backend/src/Order/order.schema.ts

import { Inject, Injectable } from '@nestjs/common';
import {
  Pothos,
  PothosRef,
  PothosSchema,
  SchemaBuilderToken,
} from '@smatch-corp/nestjs-pothos';
import { Builder } from '../Graphql/graphql.builder';
import { PrismaService } from '../Prisma/prisma.service';
import { OrderStatus } from '@prisma/client';
@Injectable()
export class OrderSchema extends PothosSchema {
  constructor(
    @Inject(SchemaBuilderToken) private readonly builder: Builder,
    private readonly prisma: PrismaService,
  ) {
    super();
  }

  // Types section
  @PothosRef()
  order() {
    return this.builder.prismaObject('Order', {
      description: 'An order in the system.',
      fields: (t) => ({
        id: t.exposeID('id', {
          description: 'The ID of the order.',
        }),
        userId: t.exposeID('userId', {
          description: 'The ID of the user.',
        }),
        paymentId: t.exposeString('paymentId', {
          description: 'The ID of the payment.',
        }),
        serviceId: t.exposeID('serviceId', {
          description: 'The ID of the service.',
        }),
        status: t.expose('status', {
          type: OrderStatus,
          description: 'The status of the order.',
        }),
        total: t.exposeInt('total', {
          description: 'The total price of the order.',
        }),
        createdAt: t.expose('createdAt', {
          type: 'DateTime',
          description: 'The date and time the order was created.',
        }),
        updatedAt: t.expose('updatedAt', {
          type: 'DateTime',
          description: 'The date and time the order was updated.',
        }),
        user: t.relation('user', {
          description: 'The user who made the order.',
        }),
        payment: t.relation('payment', {
          description: 'The payment for the order.',
        }),
        service: t.relation('service', {
          description: 'The service for the order.',
        }),
        refundTicket: t.relation('refundTicket', {
          description: 'The refund ticket for the order.',
        }),
      }),
    });
  }

  @Pothos()
  init(): void {
    // query section
    this.builder.queryFields((t) => ({
      orders: t.prismaField({
        type: [this.order()],
        description:
          'Retrieve a list of orders with optional filtering, ordering, and pagination.',
        args: this.builder.generator.findManyArgs('Order'),
        resolve: async (query, root, args, ctx, info) => {
          return await this.prisma.order.findMany({
            ...query,
            take: args.take ?? 10,
            skip: args.skip ?? 0,
            orderBy: args.orderBy ?? undefined,
            where: args.filter ?? undefined,
          });
        },
      }),
      order: t.prismaField({
        type: this.order(),
        args: this.builder.generator.findUniqueArgs('Order'),
        description: 'Retrieve a single order by its unique identifier.',
        resolve: async (query, root, args, ctx, info) => {
          return await this.prisma.order.findUnique({
            ...query,
            where: args.where,
          });
        },
      }),
    }));
    // mutation section
    this.builder.mutationFields((t) => ({
      createOrder: t.prismaField({
        type: this.order(),
        description: 'Create a new order.',
        args: {
          data: t.arg({
            type: this.builder.generator.getCreateInput('Order'),
            required: true,
          }),
        },
        resolve: async (query, root, args, ctx, info) => {
          return await this.prisma.order.create({
            ...query,
            data: args.data,
          });
        },
      }),
      deleteOrder: t.prismaField({
        type: this.order(),
        description: 'Delete an existing order.',
        args: {
          where: t.arg({
            type: this.builder.generator.getWhereUnique('Order'),
            required: true,
          }),
        },
        resolve: async (query, root, args, ctx, info) => {
          return await this.prisma.order.delete({
            ...query,
            where: args.where,
          });
        },
      }),
      updateOrder: t.prismaField({
        type: this.order(),
        description: 'Update an existing order.',
        args: {
          data: t.arg({
            type: this.builder.generator.getUpdateInput('Order'),
            required: true,
          }),
          where: t.arg({
            type: this.builder.generator.getWhereUnique('Order'),
            required: true,
          }),
        },
        resolve: async (query, root, args, ctx, info) => {
          return await this.prisma.order.update({
            ...query,
            data: args.data,
            where: args.where,
          });
        },
      }),
    }));
  }
}