Turn list relation into single item relation

[dennemark]

Hi,
is there any way i can query a one-to-many relation but limit the result to an item instead of a list?
I have the following code, but it would return a list with max. 1 item. So this is imo a deadend.

   profiles: t.relation('profiles'),
   profile: t.relation('profiles', {
      args: {
        id: t.arg({
          type: 'ID',
          required: true
        })
      },
      query: (args, context)=>({
        where: {
          profileId: args.id
        },
        take: 1
      }),
    }),

Alternative way: if i would implement it with t.field it would look like this:

profile: t.field({
      args: {
        profileId: t.arg({
          type: 'ID',
          required: true
        })
      },
      select: (args, ctx, nestedSelection)=> ({
        profiles: {
          where: {
             profileId: args.profileId
          },
          take: 1
        },
      }),
      type: 'Profile', // complains about types [1]
      resolve: (parent) => parent.profiles[0],  // complains about types [2]
    }),

However I am getting type issues:
[1] Type '"Profile"' is not assignable to type 'TypeParam<ExtendDefaultTypes>'
[2] Property 'profiles' does not exist on type

Am I doing this right?

[hayes]

You need a reference to the Profile type (Profile = builder.primsaObject('Profile',...)

You can only reference Prisma types by name in t.prismaField and other similar methods .

[dennemark]

Ah... yes that makes sense

+profile: t.prismaField({
-profile: t.field({

this helped... I should have come up with that myself.

But concerning the other type, I feel like select is not picking it up correctly when used with the function. If i use an object, then it works. But if i use an object directly, then i am not able to get the argument.

So

select: {
        profiles: true
      },
 resolve: (parent) => parent.profiles, // good!

vs

select: (args, ctx)=> ({
        profiles: true
      }),
 resolve: (parent) => parent.profiles, // not infered

[dennemark]

hm the types of resolve show me: parent.select/include

[hayes]

Sorry, I meant you need to use a reference to profile. Prisma field is the only place that using the string reference of profile works, but you can't use that method here

[dennemark]

ah wow that works! solution:

const ProfileObject = builder.primsaObject('Profile',...)

profile: t.field({
      args: {
        profileId: t.arg({
          type: 'ID',
          required: true
        })
      },
      select: (args, ctx, nestedSelection)=> ({
        profiles: nestedSelection({
          where: {
             profileId: args.profileId
          },
          take: 1
        }),
      }),
      type: ProfileObject,
      nullable: true,
      resolve: (parent) => parent.profiles?.[0],
    }),

[hayes]

One thing I'd add in your select is profiles: nestedSelection({ where: { profileId: ..., take: 1 }})

This is what adds any relations on profile of they are selected