doctor-mail/apps/server/src/models/post/post.router.ts

import { Injectable } from '@nestjs/common';
import { TrpcService } from '@server/trpc/trpc.service';
import { Prisma } from '@nice/common';
import { PostService } from './post.service';
import { z, ZodType } from 'zod';
import { PostMeta } from '@nice/common';
import { getClientIp } from './utils';
const PostCreateArgsSchema: ZodType<Prisma.PostCreateArgs> = z.any();
const PostUpdateArgsSchema: ZodType<Prisma.PostUpdateArgs> = z.any();
const PostFindFirstArgsSchema: ZodType<Prisma.PostFindFirstArgs> = z.any();
const PostDeleteManyArgsSchema: ZodType<Prisma.PostDeleteManyArgs> = z.any();
const PostWhereInputSchema: ZodType<Prisma.PostWhereInput> = z.any();
const PostSelectSchema: ZodType<Prisma.PostSelect> = z.any();
const PostUpdateInputSchema: ZodType<Prisma.PostUpdateInput> = z.any();
@Injectable()
export class PostRouter {
  constructor(
    private readonly trpc: TrpcService,
    private readonly postService: PostService,
  ) {}
  router = this.trpc.router({
    create: this.trpc.protectProcedure
      .input(PostCreateArgsSchema)
      .mutation(async ({ ctx, input }) => {
        const { staff, req } = ctx;
        // 从请求中获取 IP
        const ip = getClientIp(req);
        const currentMeta =
          typeof input.data.meta === 'object' && input.data.meta !== null
            ? input.data.meta
            : {};
        input.data.meta = {
          ...currentMeta,
          ip: ip || '',
        } as Prisma.InputJsonObject; // 明确指定类型
        return await this.postService.create(input, { staff });
      }),

    softDeleteByIds: this.trpc.protectProcedure
      .input(
        z.object({
          ids: z.array(z.string()),
          data: PostUpdateInputSchema.nullish(),
        }),
      )
      .mutation(async ({ input }) => {
        return await this.postService.softDeleteByIds(input.ids, input.data);
      }),
    restoreByIds: this.trpc.protectProcedure
      .input(
        z.object({
          ids: z.array(z.string()),
          args: PostUpdateInputSchema.nullish(),
        }),
      )
      .mutation(async ({ input }) => {
        return await this.postService.restoreByIds(input.ids, input.args);
      }),
    update: this.trpc.protectProcedure
      .input(PostUpdateArgsSchema)
      .mutation(async ({ ctx, input }) => {
        const { staff } = ctx;
        return await this.postService.update(input, staff);
      }),
    findById: this.trpc.protectProcedure
      .input(z.object({ id: z.string(), args: PostFindFirstArgsSchema }))
      .query(async ({ ctx, input }) => {
        const { staff } = ctx;
        return await this.postService.findById(input.id, input.args);
      }),
    deleteMany: this.trpc.protectProcedure
      .input(PostDeleteManyArgsSchema)
      .mutation(async ({ input }) => {
        return await this.postService.deleteMany(input);
      }),
    findManyWithCursor: this.trpc.protectProcedure
      .input(
        z.object({
          cursor: z.any().nullish(),
          take: z.number().nullish(),
          where: PostWhereInputSchema.nullish(),
          select: PostSelectSchema.nullish(),
        }),
      )
      .query(async ({ ctx, input }) => {
        const { staff } = ctx;
        return await this.postService.findManyWithCursor(input, staff);
      }),
  });
}