typescript - 使用 Prisma 生成的类型作为函数参数类型

Question

我正在尝试 Prisma ORM，看看有什么可能性。创建模型并生成 PrismaClient 之后，我认为可以使用生成的类型并将它们用于变量和响应类型，但情况似乎并非如此。

...

model Invite {
  id        Int        @id @default(autoincrement())
  gender    Gender
  firstName String     @map("first_name")
  lastName  String     @map("last_name")
  language  Language
  email     String     @unique
  token     String     @unique

  roleId Int  @map("role_id")
  role   Role @relation(fields: [roleId], references: [id])

  organisationId Int          @map("organisation_id")
  organisation   Organisation @relation(fields: [organisationId], references: [id])

  updatedAt DateTime @updatedAt @map("updated_at")
  createdAt DateTime @default(now()) @map("created_at")

  @@map("invites")
}

...

上面我有一个与组织和角色模型相关的邀请模型。在邀请服务文件中，我正在准备所有输入以创建新邀请。

import { Request, Response, NextFunction } from 'express';
import roleRepository from '../repositories/role.repository';
import organisationRepository from '../repositories/organisation.repository';
import generateToken from '../utils/helpers/generateToken';
import inviteRepository from '../repositories/invite.repository';

const createInvite = async (req: Request, res: Response) => {
    const { body } = await validateInput(req);
    const { gender, firstName, lastName, email, language, roleId, organisationId } = body;

    const role = roleRepository.findRoleById(roleId);

    if (!role) {
        throw new Error('Role does not exist');
    }

    const organisation = organisationRepository.findOrganisationById(organisationId);

    if (!organisation) {
        throw new Error('Organisation does not exist');
    }

    const token = generateToken();

    const invite = inviteRepository.createInvite({
        gender,
        firstName,
        lastName,
        email,
        language,
        role: role,
        organisation: organisation,
        token,
    });

    await mailService.sendInviteEmail(invite);

    res.status(201).json({
        message: 'Invite created successfully',
    });
};

在 inviteRepository 文件的 createInvite 函数中，我尝试使用生成的 Prisma 类型，InviteCreateInput。

const createInvite = async (inviteData: Prisma.InviteCreateInput): Promise<Invite> => {
    return db.invite.create({
        data: {
            gender: inviteData.gender,
            firstName: inviteData.firstName,
            lastName: inviteData.lastName,
            language: inviteData.language,
            email: inviteData.email,
            token: inviteData.token,
            role: {
                connect: {
                    id: inviteData.role
                }
            },
            organisation: {
                connect: {
                    id: inviteData.organisation,
                }
            }
        },
    });
};

Prisma recommends this 'safe' way of Input但 InviteCreateInput 看起来像这样

  export type InviteCreateInput = {
    gender: Gender
    firstName: string
    lastName: string
    language: string
    email: string
    token: string
    updatedAt?: Date | string
    createdAt?: Date | string
    role: RoleCreateNestedOneWithoutInviteInput
    organisation: OrganisationCreateNestedOneWithoutInvitesInput
  }

和RoleCreateNestedOneWithoutInviteInput看起来像这样:

  export type RoleCreateNestedOneWithoutInviteInput = {
    create?: XOR<RoleCreateWithoutInviteInput, RoleUncheckedCreateWithoutInviteInput>
    connectOrCreate?: RoleCreateOrConnectWithoutInviteInput
    connect?: RoleWhereUniqueInput
  }

由于此类型需要创建、connectOrCreate 或 connect，因此它似乎无法用作此函数的函数参数类型(还想知道此类型可以在什么方法中使用)。我发现 InviteUncheckedCreateInput 作为可能使用的类型，但由于 Prisma 不建议使用 unchecked 类型，我不确定这是否是一个好方法。

有人有使用 Prisma 类型作为函数参数类型的经验，还是自己创建一个类型更好？

Answer 1

Prisma 认为它“更安全”的原因是他们假设您可能没有检查 roleId 或 organizationId (您正在使用 进行检查) findRoleById 和 findOrganizationById。

为了性能，我会删除额外的查询 - findRoleById 和 findOrganizationById 并像这样编写中间件:

const createInvite = async (req: Request, res: Response) => {
  const { body } = await validateInput(req);
  const { gender, firstName, lastName, email, language, roleId, organisationId } = body;

  const token = generateToken();

  try {
    const invite = await inviteRepository.createInvite({
      gender,
      firstName,
      lastName,
      email,
      language,
      token,
      role: {
        connect: {
          id: roleId,
        },
      },
      organisation: {
        connect: {
          id: organisationId,
        },
      },
    });
  } catch (error) {
    // handle the errors from no organisationId nor roleId existing
    // next(Error) or something similar
  }

  await mailService.sendInviteEmail(invite);

  res.status(201).json({
    message: 'Invite created successfully',
  });
};

您还可以清理您的 createInvite 函数:

const createInvite = async (data: Prisma.InviteCreateInput): Promise<Invite> => {
  return db.invite.create({
    data,
  });
};