GlobalIDs with prismaObject; Using prismaObject and prismaNode in Conjunction

[arimgibson]

Trying to summarize my use case as short as possible; there's a lot going on with our setup.

Plugins: Prisma, Relay, ScopeAuth, Simple Objects

The project I'm working on has a combination of regular prismaObjects and some prismaNodes, as only certain fields need to pagination and/or need to be accessed on their own (i.e. through a node query). This helps to simplify auth as otherwise we'd need to add complex auth queries onto every single prismaNode.

Here's an minimal example that mimics the relevant parts of our setup; hope I'm explaining everything right, but bonus points if you correct something wrong with my explanation of how everything fits together!

Consider the following blog-type schema:

// note that IDs are stored as Int
model User {
  id Int @id @default(autoincrement())
  name String
  email String @unique
  post Post[]
}

model Post {
  id Int @id @default(autoincrement())
  title String
  content String
  published Boolean @default(false)
  author User @relation(fields: [authorId], references: [id])
  authorId Int
  tag Tag[]
}

// in the real world this would be a m-n relationship, using 1-m to keep things simple here (avoid join tables)
model Tag {
  id Int @id @default(autoincrement())
  post Post @relation(fields: [postId], references: [id])
  postId Int
}

Currently, our setup looks something like this:

import { builder } from './libs/pothos/src/builder';

builder.prismaNode('User', (t) => ({
  id: { field: 'id' },
}))
builder.prismaNode('Post', (t) => ({
  id: { field: 'id' },
  runScopesOnType: true,
  authScopes: (post, ctx) => ({
    canAccess: ctx.user.id === post.author_id,
  }),
  fields: {
    tag: t.field({
      type: ['Tag'],
    })
  }
}));
builder.prismaObject('Tag', (t) => ({
  fields: { ... },
}))

Because tag isn't a node and purposely isn't given a queryField, it cannot be accessed on its own without being queried through the Post it belongs to. Combine this with runScopesOnType: true on the Post, and the tag won't resolve if the user isn't authorized to view the tag without being authorized to view Post. This setup works great, because then we don't have to add authScopes onto the tag, which would require includes on the post to get the correct data to evaluate whether the user can view the post that the tag belongs to (see #851). That's not a huge issue in this example, but in the real world, they'd be like 5 or 6 nested includes to just get back up to the root field's ID to determine whether the user is authorized to access that nested field.

Queue the issue. As a prismaObject, Tag doesn't have all the logic behind the scenes to parse the Int (from the database) into a globalID type. But, for the ease of our frontend team, we'd like everything to be returned as a globalID even if it could simply be a string or Int.

It gets confusing for both sides of the tech stack when IDs aren't the same type. For example, if we query `

Potential Solutions

I see two different solutions here. One is to defer all the complexity to the frontend, and have them convert all Int into globalIDs after receiving queried data encodeGlobalID. Then, on the backend, expect everything to be a globalID and parse back decodeGlobalID to be able to use in our database queries.

The other solution is to perform this work on the backend. After a query is completed, determine which fields are Int and convert them all into globalIDs before returning to the frontend.

Lastly, we could migrate to use prismaNode for everything and implement the complex auth setup described above. It wouldn't be terrible but seems to require querying a lot of extra data than we'd like to.

As I'm writing this out, the second solution mentioned there doesn't seem as horrible to implement. However, still worth asking if there's a better way to do all this.

Hopefully all of this makes sense; typing it up late at night after trying to brainstorm off and on during the day. Happy to provide more context about our setup if there's a specific design pattern we should be using instead that might solve all our problems. Thank you!

[hayes]

You can use t.globalID to add globalID fields: https://pothos-graphql.dev/docs/plugins/relay#global-ids

builder.prismaObject('Tag', {
  fields: t => ({ 
    id: t.globalID(({
      resolve: tag => ({ id: tag.id, type: 'Type' })
    })
  }),
})

[arimgibson]

Gah, too easy. I read through that part of the documentation but had assumed it was only for use within nodes. That makes sense that it's universal. Thanks @hayes !!!