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

You are returning the wrong type in the function from which you are calling it. If you add a select clause, the returned result is thinned out to the properties of your select, while you pretend to return a full User from the wrapping function:

// The full user:
type User = {
  id: number
  name: string
  email: string
  password_hash: string
}

// Here you pretend to return a full user:
function getUser(userId): Promise<User | null> {
  return this.prisma.user.findFirst({
    where: {
      password_hash: createHash('md5')
        .update(`${userId.id}test`)
        .digest('hex'),
    },
    select: { // Here you remove some properties from the user:
      name: true,
      email: true,
    },
  });
}

You can fix it by changing the return type:

function getUser(userId): Promise<{ name: string, email: string } | null> {
   ...
}

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

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!