PrismaNode and interfaces

[enri90]

i have a problem with prismaNode and interfaces who can help me?

builder.prismaNode('Page', {
  interfaces: [Node],
  id: {
    resolve: (page) => String(page.id)
  },
  nullable: true,
  findUnique: (url) => ({
    url: String(url)
  }),
  fields: (t) => ({
    title: t.exposeString('title'),
    url: t.exposeString('url'),
  }),
});

builder.prismaNode('Post', {
  interfaces: [Node],
  id: { resolve: (post) => String(post.id) },
  nullable: true,
  findUnique: (url) => ({ url: String(url) }),
  fields: (t) => ({
    title: t.exposeString('title'),
    url: t.exposeString('url'),
  }),
});

builder.interfaceType(Node, {
  name: 'NodeClass',
  fields: (t) => ({
    id: t.field({
      type: 'ID',
      nullable: true,
      resolve: (parent) => parent.id,
    }),
  }),
  resolveType: (value) => {
    if (value instanceof Node) {
      return 'Node';
    }
    return null;
  },
});

builder.objectType('Route', {
  description: '',
  fields: (t) => ({
    node: t.field({
      type: Node,
      nullable: true,
      resolve: async (parent, args, ctx, info) => ({}),
    }),
  }),
});

query {
    route(path: "/test") {
      node {
        __typename
        id
        ... on Page {
          title
          url
        }
        ... on Post {
          title
          url
        }
      }
    }
}

"errors": [
    {
      "message": "Abstract type \"NodeClass\" must resolve to an Object type at runtime for field \"Route.node\". Either the \"NodeClass\" type should provide a \"resolveType\" function or each possible type should provide an \"isTypeOf\" function.",
      "locations": [
        {
          "line": 4,
          "column": 7
        }
      ],
      "path": [
        "site",
        "route",
        "node"
      ],

[hayes]

The basic problem here is that when you return values in this resolver:

builder.objectType('Route', {
  description: '',
  fields: (t) => ({
    node: t.field({
      type: Node,
      nullable: true,
      resolve: async (parent, args, ctx, info) => ({}),
    }),
  }),
});

GraphQL (and Pothos) only knows that the returned values are Nodes, but not what kind of nodes.

I see you tried to implement your own Node interface here:

builder.interfaceType(Node, {
  name: 'NodeClass',
  fields: (t) => ({
    id: t.field({
      type: 'ID',
      nullable: true,
      resolve: (parent) => parent.id,
    }),
  }),
  resolveType: (value) => {
    if (value instanceof Node) {
      return 'Node';
    }
    return null;
  },
});

that adds a resolveType method. This method would get each object returned from the resolver mentioned above, and should be determining if the node is a Post or a Page. The more node types you have the more complicated it gets to write a good resolveType method.

I'm also not sure if the relay plugin currently handle just defining your own node interface like that (There is still an easy way to set the resolveType method for the interface).

Instead of trying to write a resolveType method that knows and Page, Post, and every other Node type, a common approach is to use isTypeOf instead. The default resolveType implementation in Pothos does a few things:

• Checks if the object has a __typename property which it can use to figure out the type
• Checks if the object has been branded with a type (described below)
• Calls the isTypeOf method for each object type that implements the interface, to see if any of the isTypeOf methods indicate that the node object is of that type

This means that if you add an isTypeOf check to Post and Page everything should work. Writing good isTypeOf checks for prisma models can be kind of tricky, because it will be called for each node type you return, so the Page isTypeOf check would receive both Pages and Posts, and need to be able to determine based on the object if its a Page or not. If you have unique columns, this can work, but often this gets tricky especially if you have a lot of different node types.

What you can do instead is "brand" the objects after you load them. This isn't documented in the plugin docs yet, but prismaRefs have a method that makes this easy:

const Page = builder.prismaNode('Page', {...});
const Post = builder.prismaNode('Post {...});

builder.objectType('Route', {
  description: '',
  fields: (t) => ({
    node: t.field({
      type: Node,
      nullable: true,
      resolve: async (parent, args, ctx, info) => {
        const pages = await prisma.page.findMany({where: { ... } });
        const posts = await prisma.post.findMany({where: { ... } });

        return [...Page.addBrand(pages),  ...Post.addBrand(posts)];
      },
    }),
  }),
});

Branding the objects like this will allow the default resolveType method to know what types the nodes are. This means you won't have to add any custom resolveType or isTypeOf` methods