Incorrect types when extending findMany with relations

[JClackett]

When trying to compose a findMany with a relation i noticed that that the types inferred are incorrect.

// Resuable function
export default async function getPosts(args: FindManyPostArgs) {
  return db.post.findMany(args)
}



export async function getPostsWithComments(args: FindManyPostArgs) {
  const postsWithComments = await getPosts({ include: { comments: true }, ...args })
  // postsWithComments type is just Post[], no comments 
  return postsWithComments
}

I know this example is quite contrived, but there are use cases.

I would have thought that the types would have been inferred up to getPostsWithComments, is there something i am missing?

[ryands17]

Hey @JClackett 👋
I have create the same with the following schema

model User {
  id        Int      @default(autoincrement()) @id
  email     String   @unique
  password  String
  name      String?
  posts     Post[]
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

model Post {
  id        String   @default(cuid()) @id
  published Boolean
  title     String
  content   String?
  author    User?    @relation(fields: [authorId], references: [id])
  authorId  Int?
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

and on running this query, I get the following type

  const user = await prisma.user.findMany({
    include: {
      posts: true,
    },
  })

const user: (Prisma.User & {
    posts: Prisma.Post[];
})[]

So the type system should be working correctly.
Could you send me your schema so that I could replicate it?

[JClackett]

Hi @ryands17, i agree that what your saying would return the correct type, but if you created a function that returns the findMany(args) then it loses the types

example using your schema:

async function getUsers(args: FindManyUserArgs){
	const users = await prisma.user.findMany(args)
	return users
}

function SomeOtherPlace() {
	const usersWithPosts = await getUsers({
		include: {
			posts: true,
		},
	})
	
	// Now check the type of usersWithPosts
}

[ryands17]

Actually this is not a Prisma issue, but a TypeScript one. Typescript cannot infer the type if you pass in dynamic values as arguments, for the above to work, you would have to use something like function overloading in TS to map the types based on the args.