Hey @sehmaschine, unfortunately I don't think this is possible off the bat with TypeScript.

However, if you care about the naming of this particular field in your code and don't want to use the name of the DB column, you can use @map to give it a different name in your Prisma Client API. If it's a relation field, you can just manually rename it.

Without knowing your schema, it could be be something like this:

model RiskScore {
  country ConfigurationCountry 

  @@map("risk_scores")
}

model ConfigurationCountry {
  riskScore Riskscore

  @@map("configuration_countries")
}

Hi @Tanavya 👋

Why doesn't the original method work? Am I misunderstanding something?

The original method you attempted, which included both select and include operations, didn't produce the desired result because the select operation is primarily used to specify which scalar fields to include in the query result, while the include operation is used to specify related models or fields to include in the query result.

When you used both select and include together in the validator definition, the include operation might have overridden the select operation, resulting in all fields being included in the generated type, including those specified in the select operation.

In contrast, when you used only the select operation in the validator definition:

const userArgs = Prisma.validator<Prisma.UserDefaultArgs>()({
  select: { email: true, name: true, posts: true },
});

You explicitly specified the fields you wanted to include in the generated type, which ensured that only those fields were included and that the include operation didn't interfere with the selection of scalar fields.

How do I get a type where some fields are optional and can also include relations? For example to reiterate, for my use case I would like fields like id, createdAt, updatedAt to be optional. So I want a more general type like UserModel which includes relations and each sub-model and the "root" level User model can have fields that can be undefined, but are still required in the schema. This way I can use the same model as both input and output for create and get methods.

If you want to create a type where some fields are optional and can also include relations, you would have to manually create these types in your application code. Here's an example:

type PartialUser = Partial<Prisma.UserCreateInput & {{
  posts: Prisma.PostCreateNestedManyWithoutAuthorInput;
}}>;

In this example, PartialUser is a type that includes all fields of the User model and the posts relation, and all these fields are optional. However, this approach increases the maintenance burden upon changes to the Prisma schema as you need to manually maintain the types.

This works as expected. Computed fields get their own entry in select:

const user = await prisma.user.findFirstOrThrow({
  where: { email: 'test@me.com' },
  select: { fullName: true },
})

Motivation for this design is that needs are implementation detail of particular field: otherwise, if tomorrow middleName would also become a part of fullName, you'd have to update every single select that needs fullName.

Hey @DavidRodarte 👋 ,

You have defined your getTickets function to return Ticket[], but since you are only selecting uuid in your query, the return type will only include the uuid field as well.

If you change your function signature, it should fix the problem.

async getTickets(): Promise<{uuid: string}[]> {
  ...
}

Let me know if that works!

Hey @mikevarela 👋

For question 1, can you try using Promise.all to execute multiple queries in parallel?

For question 2, you can use Prisma Client Extension to transform the response before sending it to the client. But I believe you might need to use a for loop in this case as well.

Overall, the best approach will depend on the specific requirements of your application. If you expect to have a large number of select lists, each with a large number of options, then it may be more efficient to create separate API endpoints for each select list. However, if you only have a few select lists with a small number of options, then a single API endpoint may be simpler to manage.