Relay Node interface resolver

[FezVrasta]

I'm trying to implement a Relay Node interface resolver.

This is my current implementation, it relies on the assumption every node query will include a fragment on the GraphQL object Relay is trying to fetch, for example:

query MyQuery {
	node(id: "2467aacc-3ac7-45a4-a4a4-e2b14587c2c6") {
    id
    ... on CreatorNode {
      name
    }
  }
}

So even though Prisma doesn't have global identifiers I can understand what model to fetch using the GraphQL query AST as source.

import { DefinitionNode, SelectionNode, parse } from "graphql";
import { Arg, Ctx, Query, Resolver } from "type-graphql";

import { prisma } from "@/prisma";
import { RelayNode } from "@/types/relay-node";
import { Prisma } from "@generated/prisma-client";

import { GraphQLContext } from "..";
import { CreatorNode, ProductPriceNode } from "./creators";

/**
 * Node Resolver
 */
@Resolver()
export class NodesResolver {
  @Query(() => RelayNode, { nullable: true })
  async node(@Arg("id") id: string, @Ctx() ctx: GraphQLContext) {
    if (ctx.params.query == null) {
      return null;
    }

    const fragmentTypes = extractFragmentTypes(ctx.params.query);
    const firstFragmentType = fragmentTypes[0];

    if (firstFragmentType == null) {
      return null;
    }

    const modelName = lowerCaseFirstChar(
      firstFragmentType.replace(/Node$/, ""),
    ) as TPrismaModels;

    // @ts-expect-error This is a dynamic property access
    const node = await prisma[modelName].findUnique({ where: { id } });

    return node;
  }
}


export const resolvers = [NodesResolver] as const;

/**
 * Utilities
 */
function extractFragmentTypes(query: string): string[] {
  const fragmentTypes: string[] = [];
  const ast = parse(query);

  // Traverse the AST to find fragment definitions
  function extractFragments(node: DefinitionNode | SelectionNode) {
    console.log(node);
    if (node.kind === "InlineFragment" && node.typeCondition) {
      fragmentTypes.push(node.typeCondition.name.value);
    }
    if ("selectionSet" in node && node.selectionSet) {
      node.selectionSet.selections.forEach((selection) => {
        extractFragments(selection);
      });
    }
  }

  ast.definitions.forEach((definition) => {
    extractFragments(definition);
  });

  return fragmentTypes;
}

function lowerCaseFirstChar(s: string): string {
  return s[0].toLowerCase() + s.slice(1);
}

type LowercaseFirstChar<S extends string> =
  S extends `${infer First}${infer Rest}` ? `${Lowercase<First>}${Rest}` : S;
type TPrismaModels = LowercaseFirstChar<keyof typeof Prisma.ModelName>;

Unfortunately this errors with:

ERR Error: Cannot resolve type for interface Node! You need to return instance of object type class, not a plain object!

A workaround I found is to manually instantiate the correct instance with this code:

    let instance;

    switch (modelName) {
      case "creator":
        instance = new CreatorNode();
        break;
      case "productPrice":
        instance = new ProductPriceNode();
        break;
      default:
        throw new Error(
          `Unknown model: ${modelName}, make sure to implement it in the node resolver.`,
        );
    }

    for (const key in node) {
      instance[key as keyof typeof instance] = node[key];
    }

    return instance;

The problem is I have to manually list every single node object type here, I would like a general purpose solution.

Does anyone know how to simplify this?