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.

It's explained in the documentations of Select fields and Relation Queries That include and select have different usage:

By default, when a query returns records [..], the result includes the default selection set:

All scalar fields defined in the Prisma schema [..and] None of the relations

To change this behavior, you can use:

(1) Select:

allows you to either return a limited subset of fields instead of all fields:

const getUser: object | null = await prisma.user.findUnique({
  where: {
    id: 22,
  },
  select: {
    email: true,
    name: true,
  },
})

// Result
{
  name: "Alice",
  email: "[email protected]",
}

or include relations and select relation fields (nested usage):

const users = await prisma.user.findMany({
  select: {
    name: true,
    posts: {
      select: {
        title: true,
      },
    },
  },
})

(2) Include:

allows you to return some or all relation fields (which are not returned by default as mentioned before):

const getPosts = await prisma.post.findMany({
  where: {
    title: {
      contains: 'cookies',
    },
  },
  include: {
    author: true, // Return all fields
  },
})

// Result:
;[
  {
    id: 17,
    title: 'How to make cookies',
    published: true,
    authorId: 16,
    comments: null,
    views: 0,
    likes: 0,
    author: {
      id: 16,
      name: null,
      email: '[email protected]',
      profileViews: 0,
      role: 'USER',
      coinflips: [],
    },
  },
  {
    id: 21,
    title: 'How to make cookies',
    published: true,
    authorId: 19,
    comments: null,
    views: 0,
    likes: 0,
    author: {
      id: 19,
      name: null,
      email: '[email protected]',
      profileViews: 0,
      role: 'USER',
      coinflips: [],
    },
  },
]

(3) Select within Include:

Finally, you can use Select within Include, to return a subset of the relation fields.

const users = await prisma.user.findMany({
  // Returns all user fields
  include: {
    posts: {
      select: {
        title: true,
      },
    },
  },
})

I'm stealing this directly from nikolasburk's reply in slack:

Hey Aurora. :wave:

- include is only for relation fields and is used when you want to additionally include relations in addition to all the scalar fields that are returned by default

- select is used when you want to only return certain fields but exclude other ones (like a password field)

This page in the docs should give you more info about this as well :slightly_smiling_face: https://www.prisma.io/docs/concepts/components/prisma-client/select-fields#return-the-default-selection-set

For rows, findMany() without where will return all rows in table:

Get all Records
The following findMany query returns all User records:

const users = await prisma.user.findMany()

For columns/fields, without specifying include or select, prisma has a default:

By default, when a query returns records (as opposed to a count), the result includes the default selection set:

• All scalar fields defined in the Prisma schema (including enums)
• None of the relations

For SELECT * FROM application (does not include users relation):

const applications = await prisma.application.findMany();

To futher include users relation in the model:

const applications = await prisma.application.findMany({
  include: {
    users: true // will include all fields
  }
});