How to use enum in resolver?

[marceloverdijk]

I'm trying to use the following enum definition in a prismaObject:

gender.ts:

import builder from '../builder'

builder.enumType('Gender', { 
  values: ['MALE', 'FEMALE'] as const,
})

In the database it is not a enum, just a plain string.

Then with this prismaObject:

person.ts:

import builder from '../builder'

builder.prismaObject('Person', {
  findUnique: (person) => ({ id: person.id }),
  fields: (t) => ({
    id: t.exposeString('id'),
    name: t.exposeString('name'),
    gender: t.field({
      type: 'Gender',
      resolve: (parent) => parent.gender,
    }),
})

it complains about the gender field:

Type 'string' is not assignable to type 'MaybePromise<readonly unknown[]> | null | undefined'.

It seems it cannot map the parent.gender (== string) to the Gender type.

Do I need to convert it somehow?

[hayes]

Enums can be used in 2 ways. You can either use a typescript enum (eg if this is an enum that exists in your prisma schema, you can import that. In that case, you pass the enum when defining it:

import { MyEnum } from '@prisma/client'

builder.enumbType(MyEnum, { name: 'MyEnum' })

builder.prismaObject('Person', {
  fields: (t) => ({
    myField: t.field({
      type: MyEnum,
      resolve: (parent) => MyEnum.enumValue,
    }),
    myField: t.expose('myField', {
      type: MyEnum,
    }),
})

Or you can create your own enums, in this case you need the return value of the builder.enumType method:

const MyEnum = builder.enumbType('MyEnum', { values:  ['SomeValue'] as const })
builder.prismaObject('Person', {
  fields: (t) => ({
    myField: t.field({
      type: MyEnum,
      resolve: (parent) => 'SomeValue'
    }),
    myField: t.expose('myField', {
      type: MyEnum,
    }),
})

[marceloverdijk]

Ok thx, I tried the second option like:

gender.ts:

import builder from '../builder'

export const Gender = builder.enumType('Gender', { 
  values: ['MALE', 'FEMALE'] as const,
})

person.ts:

import builder from '../builder'
import { Gender } from './gender'

builder.prismaObject('Person', {
  findUnique: (person) => ({ id: person.id }),
  fields: (t) => ({
    id: t.exposeString('id'),
    name: t.exposeString('name'),
    gender: t.expose('gender', {
      type: Gender,
    }),
})

but it gives a Argument of type 'string' is not assignable to parameter of type 'never'. ts(2345) error on the argument part of t.expose('gender',

Likely I'm overseeing something obvious...

[hayes]

The type errors for expose probably could be improved, and don't give a good indication of the problem. In this case, the issue is that the gender porperty on you Prisma object is not compatible (in a type-safe way) with the type/field you are defining, it could be that the db column is not required (in this case the field needs to be nullable), or the db column is a string and ts doesn't know it will be one of the enum values. You can define it as a field (with the same type) and a simple resolver like resolve: person => person.gender to see a better error message. Defining the field like this would also allow you to do a type cast or type assertion if the issue is that the db type doesn't match the enum you are trying to return, but you know the values should match. I feel like there is probably something ironic about trying to define gender as a binary enum, and the type system trying to hint that this isn't a safe assumption.

[marceloverdijk]

Yes indeed, it's because of the database value is just a string.

I tried like:

    gender2: t.field({
      type: Gender,
      resolve: (person) => person.gender
    }),

>> Type 'string' is not assignable to type 'MaybePromise<"MALE" | "FEMALE">'.

and

    gender3: t.field({
      type: Gender,
      resolve: (person) => person.gender as keyof typeof Gender
    }),

>> Type 'keyof EnumRef<"MALE" | "FEMALE", "MALE" | "FEMALE">' is not assignable to type 'MaybePromise<"MALE" | "FEMALE">'.

but without luck. I guess I need another way to cast it somehow...

[hayes]

You have a couple options, but fundamentally you have a string type you need to cast in your resolver. In order to do that you can do a few things. You can use the typescript enum method described above or one of the 2 options below:

define the type manually

type EnumType = `val1` | `val2`

const MyEnum = builder.enumType('MyEnum', { values: ['val1`, `val2`] as EnumType })

...
resolve: (parent) => parent.value as EnumType

or
Extract the type from the enum ref:

type EnumTpe = typeof MyEnum extends InputRef<infer T> ? T : never

You can also do some combination like:

const EnumValues = ['val1', 'val2'] as const
const MyEnum = builder.enumType('MyEnum', { values: EnumValues })
...
resolve: (parent) => parent.value as typeof EnumValues[number]

[abdofola]

@hayes I have my enum type defined in prisma when I tried your solution I got this error

Error: Ref [object Object] has not been implemented

but when I added a new scalar type in the builder object like this example
it works well!

[marceloverdijk]

As I don't want to repeat the enum values I came up with this solution which to me is the most clean + shortest on code:

export enum Gender {
  MALE,
  FEMALE,
}

builder.enumType(Gender, { 
  name: 'Gender',
})

builder.prismaObject('Person', {
  findUnique: (person) => ({ id: person.id }),
  fields: (t) => ({
    id: t.exposeString('id'),
    name: t.exposeString('name'),
    gender: t.field({
      type: Gender,
      resolve: (person) => Gender[person.gender as keyof typeof Gender],
    }),
  }),
})

Thx for your help.

[AnthonyZhang220]

I am still getting PothosSchemaError: Ref [object Object] has not been implemented from this pattern. My enum is

export enum Visible {
	Everyone = "Everyone",
	Friend = "Friend",
	Me = "Me",
}
...
builder.prismaObject("Post", {
	fields: (t) => ({
		id: t.exposeString("id"),
...
		**visibleTo: t.field({
			type: Visible,
			resolve: (post) => post.visibleTo as Visible,
		}),**
	}),
});
...
export const PostCreateInput = builder.inputType("PostCreateInput", {
	fields: (t) => ({
		title: t.string({ required: true }),
		published: t.boolean({ required: true }),
		**visibleTo: t.field({ type: Visible, required: true }),**
		content: t.string({ required: true }),
		hasMedia: t.boolean({ required: true }),
	}),
});
...
builder.mutationFields((t) => ({
	createDraft: t.prismaField({
		type: "Post",
		args: {
			data: t.arg({
				type: PostCreateInput,
				required: true,
			}),
			author: t.arg.string({ required: true }),
		},
		resolve: (query, parent, args) => {
			return prisma.post.create({
				...query,
				data: {
					title: args.data.title,
					content: args.data.content ?? undefined,
					published: args.data.published,
					**visibleTo: args.data.visibleTo,**
					hasMedia: args.data.hasMedia,
					author: {
						connect: {
							id: args.author,
						},
					},
				},
			});
		},
	}),
);

It does not seem to recognize my visibleTo type in data either.

[hayes]

You still need to add the enum to the builder:

builder.enumType(Visible, { 
  name: 'Visible',
})

[AnthonyZhang220]

My bad, now it works!

[max-petrenko]

Though the question is answered already, it has helped me with my Pothos + Prisma setup, so even though Prisma-expoerted Enums are not strictly TS enums, I'll post a way to incorporate them into Pothos builder here just in case:

const builder = new SchemaBuilder<{
  PrismaTypes: PrismaTypes
}>({
  plugins: [PrismaPlugin],
  prisma: {
    client: prisma,
  },
})

import { MemberType } from '@prisma/client' // Prisma-defined enums are exported as both a string union and a const object, under the same name

builder.enumType(MemberType, {
    name: 'MemberType'
})

builder.queryType({})

builder.prismaObject('Member', {
  fields: t => ({
    // other fields

    memberType: t.field({
      type: MemberType,
      resolve: member => member.memberType, // becomes $Enums.MemberType, which is treated like enum values' union
    }),
}),
})

[arimgibson]

Building off @max-petrenko 's answer, I came up with this pattern:

import { $Enums } from '@prisma/client';
import { builder } from './builder';

// To use enums in a resolver, import the type directly from Prisma

// Note: Prisma enums not used in a model are not created as
// types in the Prisma client, so they aren't added to GraphQL here
// https://github.com/prisma/prisma/issues/13382

// Automatically create Builder enum types from Prisma Typescript enums
Object.entries($Enums).forEach(([name, type]) => {
  builder.enumType(type, {
    name,
  });
});

[abdofola]

You can also define a scalar type in your builder object like so:

type Gender = 'MALE' | 'FEMALE';

const builder = new SchemaBuilder<{Input:Gender, Output:Gender}>({});

builder.scalarType("Gender", {
  serialize: (t) => t,
  parseValue: (t) => {
    if (t !== "MALE" && t !== "FEMALE")
      throw new Error(`the "gender" field must be 'MALE' or 'FEMALE'`);
    return t;
  },
});

then use it this way:

...
gender: t.expose('gender',{type:'Gender'}) 

[max-taylor]

And to slightly reduce the amount of if statement comparisons required:

const genderValues = ["MALE", "FEMALE", "OTHER"] as const;

export type Gender = typeof genderValues[number];

builder.scalarType("Gender", {
  serialize: (t) => t,
  parseValue: (t) => {
    if (!genderValues.some(t))
        throw new Error(
            `the "gender" field must be one of ${genderValues.join()}`
        );
    return t;
  },
});