Hey @andreasqlight 👋 ,

You should be able to import any of Prisma's generated types from the @prisma/client package.

model User {
 ...
}

import type { User } from '@prisma/client'

Let me know if that works!

You should just be able to run the generate command and it should generate the TS types for you.

According to the Prisma docs:

The generate command generates assets like Prisma Client based on the generator and data model blocks defined in your prisma/schema.prisma file.

Checkout the docs here

Try running this in your terminal:

npx prisma generate

or adding a script to your package.json like so:

{
  "scripts": {
    "generate": "prisma generate"
  }
}

and calling it using your preferred package manager CLI:

# with npm
npm run generate

# with yarn
yarn generate

# with pnpm
pnpm generate

Hope this answers your question!

That should do the trick:

import type { User } from '@prisma/client'

@thomasmorice 👋

Could you share your use case of where you would want to use this? I could provide an alternative solution if I can understand your use case better 🙂

The reason Prisma suggest it's "safer" is because they assume that you may not be checking for the roleId or the organisationId (which you are doing with findRoleById and findOrganisationById.

For performance, I would remove the extra queries - findRoleById and findOrganisationById and write your middleware like so:

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',
  });
};

You could also clean up your createInvite function:

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

An alternate method (my preferrence) to get the "full" type, or the model with all of its possible relations, is to use the GetPayload version of your model type. The type is a generic that can receive the same object you pass to your query.

import { PrismaClient, Prisma } from "@prisma/client";

const prisma = new PrismaClient();

type UserWithCars = Prisma.UserGetPayload<{
  include: {
    cars: true;
  }
}>

const usersWithCars = await prisma.user.findMany({
  include: {
    cars: true,
  }
});

As your query grows more complex, you may want to abstract it and ensure that it is strongly typed.

import { Prisma, PrismaClient } from "@prisma/client";

const prisma = new PrismaClient();

const userInclude = Prisma.validator<Prisma.UserInclude>()({
  cars: true,
});

type UserWithCars = Prisma.UserGetPayload<{
  include: typeof userInclude;
}>;

const usersWithCars = await prisma.user.findMany({
  include: userInclude,
});