Prisma + Relay with Intefaces/Unions

[haleksandre]

I have a hard time making Prisma and Relay work with an interface & was wondering if it's possible or if I'm overcomplicating things & there is a better approach to solving this.

The problem is like so:

I have an Activity model which has some data, like which user the activity is for & has relations to other more specific activities such as Entry & Event. So I would like to have these Activity model acts as an interface for the Event & Entry models to make it possible to query activities like so

activities {
  edges {
    node {
      common
      ...on Event {
        event-specific
      }
      ...on Entry {
        entry-specific
      }
    }
  }
}

So far I have a 'regular' interface using the builder.interfaceRef().implement()

export const Activity = builder.interfaceRef<Activity>("Activity");

Activity.implement({
  resolveType: (root) => {
    // receive activity data (prisma.activity)
    // parse activity relation & resolve Event or Entry otherwise Error...
  },
  fields: (t) => ({
    // Common fields
  }),
});

export const Entry = builder.prismaNode("Entry", {
  interfaces: [Activity],
  id: { field: "id" },
  fields: (t) => ({
    // Common fields
    // Entry fields
  }),
});

export const Event = builder.prismaNode("Event", {
  interfaces: [Activity],
  id: { field: "id" },
  fields: (t) => ({
    // Common fields
    // Event fields
  }),
});

So far so good, I can use this interface with the t.field() with no problem. But I would like to be able to use relay connections. The problem is since Activity is an interface & not a PrismaNode nor a Node, it looks like I'm not able to use the t.prismaConnection() or t.connection({ type: Activity }) helper.

I tried using t.connection() helper with resolveCursorConnection (https://pothos-graphql.dev/docs/plugins/relay#creating-connections) as well as making a builder.connectionObject({ type: Activity }) (https://pothos-graphql.dev/docs/plugins/relay#reusing-connection-objects) but I'm unable to make any of them work correctly.

Am I missing something or as mentioned earlier there are simpler ways to achieve the desired query above?

[haleksandre]

I was able to achieve what I wanted by adding the Node ref to the interface but Typescript still complains about the typing.

const Node = builder.nodeInterfaceRef();

export const Activity = builder.interfaceRef<Activity | Event | Entry>("Activity");

Activity.implement({
  interfaces: [Node],
  resolveType: (root) => {
    // receive activity data (prisma.activity)
    // parse activity relation & resolve Event or Entry otherwise Error...
  },
  fields: (t) => ({
    // Common fields
  }),
});

// use Activity like so

...
activities: t.connection({
  type: Activity,
  canRefetch: true,
  resolve: async (_root, args, { prisma }) =>
    // @ts-expect-error: typing
    resolveCursorConnection(
      { args, toCursor: ({ id }) => id },
      // Manually defining the arg type here is required
      // so that typescript can correctly infer the return value
      async ({
        before,
        after,
        limit,
        inverted,
      }: ResolveCursorConnectionArgs) =>
        prisma.activity.findMany({
          include: {
            event: true,
            entry: true,
          },
          take: limit,
          where: {
            createdAt: {
              lt: before,
              gt: after,
            },
          },
          orderBy: {
            createdAt: inverted ? "desc" : "asc",
          },
        })
    ),
}),
...

The problem now is that the expect error as TypeScript doesn't like the return type of resolveCursorConnection

[hayes]

what is the type error you are seeing, this looks like it should work

[haleksandre]

import { builder } from "../builder.js";
import { Activity } from "./interface.js";
import { ActivityCreateInput } from "./input.js";
import { queryFromInfo } from "@pothos/plugin-prisma";

export const Mutation = builder.mutationFields((t) => ({
  activity: t.field({
    type: Activity,
    description: "Create an activity entry",
    args: {
      data: t.arg({ type: ActivityCreateInput, required: true }),
    },
    resolve: async (_root, { data }, { prisma, ...ctx }, info) => {
      return prisma.activity.create({
        ...queryFromInfo({
          context: { prisma, ...ctx },
          info,
          // typeName: "Entry",  returns an object but for the Prisma `entry` model so it errors here
          // path: ["some-field"] returns an empty object regardless of what value is here because returnType Activity returns an empty object
        }),
        data,
      });
    },
  }),
}));

I've encountered a new issue with the interface above & queryFromInfo. During an Activity mutation the queryFromInfo always returns an empty object unless I explicitly put typeName: "Event" or typeName: "Event". It also returns an empty object even if I use the path property since when you specify a path it ignores the explicit typeName & uses the returnType, which is always an empty object. Any Idea how I could produce a queryFromInfo on an interface?

[hayes]

I think the simple answer here is that this doesn't work. Prisma doesn't have a way to write polymorphic queries, so there isn't a good way for pothos to generate the appropriate prisma queries.

If you have something like:

model Activity {
  id: ID
  entry: Entry?
  event Event?
}

you could potentially do something like:

prisma.activity.create({
    {
      include: {
       event: queryFromInfo({context, info, typeName: "Event", path: ['edges', 'node'] }),
       entry: queryFromInfo({context, info, typeName: "Entry", path: ['edges', 'node'] }),
   },
   data
});

queryFromInfo needs to generate a query for a specific type. You can define where to get the selection with path, and you can define the type the selection is for using typeName option, but the end result will always need to be a selection for a concrete type.

I haven't tested the above, and it's possible that typeName and path elements don't play well together (eg, parentType is checked before applying the path, so it bails because the returnType is a ConnectionObject) but hopefully this helps.

[hayes]

looking over the code, I think there may be an issue where path and the typeName don't work correctly together. I believe that this line here: https://github.com/hayes/pothos/blob/main/packages/plugin-prisma/src/util/map-query.ts#L362 should be adding the expected typeName to the final item in the array.

[hayes]

that issue should be fixed now