Excessive stack depth comparing types when using inputRef

[haleksandre]

I'm getting lots of Excessive stack depth comparing types error in VSCode when creating Prisma Input using inputRef with a large Prisma schema. Not sure if this is a Prisma issue or how Pothos InputRef typing issue or possibly could even be a TypeScript limitation?

Although I get these error in VSCode the GraphQL app still seem to work without any issue. Any idea what could cause these error?

[hayes]

Not sure if I understand the question here, but an inputRed should describe the shape of your GraphQL input type, what are you passing into the InputRef? Many/most of Prismas types can't be represented accurately in graphql.

[haleksandre]

An example of what I mean is if I declare input types using Prisma's CRUD input typing like so

// User 1:1 Profile Relationa

export const UserCreateInput = builder 
  .inputRef<Prisma.UserCreateInput>("UserCreateInput") // <-- Excessive stack depth Error
  .implement({
    description: "The user create fields",
    fields: (t) => ({
      email: t.field({ type: "Email", required: true }),
      username: t.field({ type: "String", required: true }),
      password: t.field({ type: "String", required: true }),
      type: t.field({ type: UserType, required: false }),
      status: t.field({ type: UserStatus, required: false }),
      profile: t.field({ type: ProfileCreateOneInput, required: false }), // <-- Adding this relation causes the Excessive stack depth
    }),
  });

export const ProfileCreateInput = builder
  .inputRef<Prisma.ProfileCreateWithoutUserInput>("ProfileCreateInput")
  .implement({
    description: "The profile create fields",
    fields: (t) => ({
      firstName: t.field({ type: "String", required: true }),
      middleName: t.field({ type: "String", required: false }),
      lastName: t.field({ type: "String", required: true }),
      avatar: t.field({ type: "String", required: false }),
      gender: t.field({ type: Gender, required: true }),
      birthday: t.field({ type: "DateTime", required: true }),
    }),
  });

export const ProfileCreateOneInput = builder
  .inputRef<Prisma.ProfileCreateNestedOneWithoutUserInput>(
    "ProfileCreateOneInput"
  )
  .implement({
    fields: (t) => ({
      create: t.field({ type: ProfileCreateInput, required: true }),
    }),
  });

Will give this error

Excessive stack depth comparing types '{ description: string; fields: 
(t: InputFieldBuilder<ExtendDefaultTypes<Schema>, "InputObject">) 
=> { email: InputFieldRef<string, "InputObject">; ... 5 more ...; employee: 
InputFieldRef<...>; }; }' and 'InputObjectTypeOptions<ExtendDefaultTypes<Schema>, 
InputFieldsFromShape<{ type?: UserType | null | undefined; activation?: 
{ create?: { expiredAt: string | { valueOf: (() => Object) & {}; ... 43 more ...; 
getVarDate: {}; }; code: string; } | { ...; } | null | undefined; connectOrCreate?: 
{ ...; } | ... 1 more ... | ...'.ts(2321)

The goal I'm trying to achieve with this is to mimick as close as possible Prisma's CRUD input for the Query/Mutation args.

export const UserWhereUniqueInput = builder
  .inputRef<Prisma.UserWhereUniqueInput>("UserWhereUniqueInput")
  .implement({
    description: "The user unique filter fields",
    fields: (t) => ({
      id: t.field({ type: "String" }),
      email: t.field({ type: "Email" }),
      username: t.field({ type: "String" }),
    }),
  });

export const Query = builder.queryFields((t) => ({
  user: t.prismaField({
    type: "User",
    description: "The selected user",
    args: { where: t.arg({ type: UserWhereUniqueInput, required: true }) },
    nullable: true,
    resolve: async (query, _root, { where }, { prisma }) =>
      prisma.user.findUniqueOrThrow({
        ...query,
        where,
      }),
  }),
}));

Which give the query flexibility to use any of the unique fields

// ID
query User {
  user(where: {id: "id"}) {
    id
    email
    username
    profile {
      firstName
      lastName
    }
  }
}

// Email
query User {
  user(where: {email: "[email protected]"}) {
    id
    email
    username
    profile {
      firstName
      lastName
    }
  }
}

I'd like to use inputRef instead of a simple inputType since it would type check all oof the input/args fields using Prisma's own CRUD input types.

[hayes]

Do you have a reproduction you can share? Also might be helpful to get the typescript version you are running.

I tried to replicate this in one of the examples I have, and was able to define the same relations:

I suspect this is actually related to the complexity/deeply nested nature of prisma types, and that other relations you have on user/profile are causing the issue.

Pothos needs to do some complex conversions on types you pass into the ref. Basically the type you are passing in won't be exactly the type pothos uses to represent your input type when its used in args. This is primarily to account for how nullability works on graphql. Unfortunately this means you probably can't pass these inputs directly to prisma. This transform could be hitting some recursive type that isn't handled safely. The inputRef pattern really is meant to be used to model exactly what you are defining in graphql, and doesn't work as well as a way to enforce compatibility with a more complex type that has other purposes.

Long term, the plugin discussed in #544 is how these types should be define. That is likely going to be the best path forward for building input types that are fully compatible with prisma, unfortunately I haven't been able to build support for mutations (create/update) yet.

A potential workaround in the short term would be to use Pick to select a more specific subset of the things you are defining for your input type. (eg Pick<Prisma.ProfileCreateNestedOneWithoutUserInput, 'create'>.