Create relay node field

node.js

import { nodeDefinitions } from './nodeDefinitions.js';

const { nodeField, nodeFields, nodeInterface, defineNodeType } = nodeDefinitions();

export { nodeField, nodeFields, nodeInterface, defineNodeType };

nodeDefinitions.js

import {
  fromGlobalId as fromRelayId,
  nodeDefinitions as relayNodeDefinitions,
} from 'graphql-relay';

const UNREGISTERED_NODE_TYPE = 'UNREGISTERED_NODE_TYPE';

export const nodeDefinitions = () => {
  const definitions = {};

  const { nodeInterface, nodeField, nodeFields } = relayNodeDefinitions(
    (...args) => resolveNodeObject(definitions, ...args),
    (...args) => resolveNodeType(definitions, ...args),
  );

  const defineNodeType = ({ type, resolve }) => {
    definitions[type.name] = { type, resolve, ResolveType: () => {} };
  };

  return { nodeInterface, nodeField, nodeFields, defineNodeType };
};

export const resolveNodeObject = async (definitions, globalId, ...rest) => {
  const { type: name, id } = fromRelayId(globalId);
  if (!definitions[name]) {
    throw new Error(UNREGISTERED_NODE_TYPE);
  }
  const { resolve, ResolveType } = definitions[name];
  const obj = await resolve(id, ...rest);
  return obj ? Object.assign(new ResolveType(), obj) : null;
};

export const resolveNodeType = (definitions, obj) => {
  const definition = Object.values(definitions).find(
    ({ ResolveType }) => obj instanceof ResolveType,
  );
  if (!definition) {
    throw new Error(UNREGISTERED_NODE_TYPE);
  }
  return definition.type;
};

UserType.js

import { GraphQLObjectType } from 'graphql';
import { globalIdField } from 'graphql-relay';

import { nodeInterface, defineNodeType } from './node';
import { findById } from '../models/User';

export const UserType = new GraphQLObjectType({
  name: 'User',
  fields: {
    id: globalIdField('User')
  },
  interfaces: [nodeInterface],
});

export default UserType;

defineNodeType({
  type: UserType,
  resolve: findById,
});