collect-system/apps/server/src/models/course/course.router.ts

import { Injectable } from '@nestjs/common';
import { TrpcService } from '@server/trpc/trpc.service';
import { Prisma, UpdateOrderSchema } from '@nice/common';
import { CourseService } from './course.service';
import { z, ZodType } from 'zod';
const CourseCreateArgsSchema: ZodType<Prisma.CourseCreateArgs> = z.any();
const CourseUpdateArgsSchema: ZodType<Prisma.CourseUpdateArgs> = z.any();
const CourseCreateManyInputSchema: ZodType<Prisma.CourseCreateManyInput> =
  z.any();
const CourseDeleteManyArgsSchema: ZodType<Prisma.CourseDeleteManyArgs> =
  z.any();
const CourseFindManyArgsSchema: ZodType<Prisma.CourseFindManyArgs> = z.any();
const CourseFindFirstArgsSchema: ZodType<Prisma.CourseFindFirstArgs> = z.any();
const CourseWhereInputSchema: ZodType<Prisma.CourseWhereInput> = z.any();
const CourseSelectSchema: ZodType<Prisma.CourseSelect> = z.any();

@Injectable()
export class CourseRouter {
  constructor(
    private readonly trpc: TrpcService,
    private readonly courseService: CourseService,
  ) {}
  router = this.trpc.router({
    create: this.trpc.protectProcedure
      .input(CourseCreateArgsSchema)
      .mutation(async ({ ctx, input }) => {
        const { staff } = ctx;

        return await this.courseService.create(input, { staff });
      }),
    update: this.trpc.protectProcedure
      .input(CourseUpdateArgsSchema)
      .mutation(async ({ ctx, input }) => {
        const { staff } = ctx;
        return await this.courseService.update(input, { staff });
      }),
    createMany: this.trpc.protectProcedure
      .input(z.array(CourseCreateManyInputSchema))
      .mutation(async ({ ctx, input }) => {
        const { staff } = ctx;

        return await this.courseService.createMany({ data: input }, staff);
      }),
    deleteMany: this.trpc.procedure
      .input(CourseDeleteManyArgsSchema)
      .mutation(async ({ input }) => {
        return await this.courseService.deleteMany(input);
      }),
    findFirst: this.trpc.procedure
      .input(CourseFindFirstArgsSchema) // Assuming StaffMethodSchema.findMany is the Zod schema for finding staffs by keyword
      .query(async ({ input }) => {
        return await this.courseService.findFirst(input);
      }),
    softDeleteByIds: this.trpc.protectProcedure
      .input(z.object({ ids: z.array(z.string()) })) // expect input according to the schema
      .mutation(async ({ input }) => {
        return this.courseService.softDeleteByIds(input.ids);
      }),
    updateOrder: this.trpc.protectProcedure
      .input(UpdateOrderSchema)
      .mutation(async ({ input }) => {
        return this.courseService.updateOrder(input);
      }),
    findMany: this.trpc.procedure
      .input(CourseFindManyArgsSchema) // Assuming StaffMethodSchema.findMany is the Zod schema for finding staffs by keyword
      .query(async ({ input }) => {
        return await this.courseService.findMany(input);
      }),
    findManyWithCursor: this.trpc.protectProcedure
      .input(
        z.object({
          cursor: z.any().nullish(),
          take: z.number().optional(),
          where: CourseWhereInputSchema.optional(),
          select: CourseSelectSchema.optional(),
        }),
      )
      .query(async ({ ctx, input }) => {
        return await this.courseService.findManyWithCursor(input);
      }),
    findManyWithPagination: this.trpc.procedure
      .input(
        z.object({
          page: z.number().optional(),
          pageSize: z.number().optional(),
          where: CourseWhereInputSchema.optional(),
          select: CourseSelectSchema.optional(),
        }),
      ) // Assuming StaffMethodSchema.findMany is the Zod schema for finding staffs by keyword
      .query(async ({ input }) => {
        return await this.courseService.findManyWithPagination(input);
      }),
  });
}