If you're running into errors with nullable Pothos types allowing both null and undefined, try this!

[colinparsonscom]

Random note in case anyone runs into the same issue I was running into a little while ago. I was specifying certain fields as nullable in my Pothos builder, but what I really wanted was for these fields to allow undefined (but not null). To handle null the same way I'd handle undefined, I would've had to update my interfaces and functions in my business logic to allow null for all types that also allowed undefined.

To save myself all that work, I found a great SO post that includes a recursive mapper from null to undefined. The code is as follows:

type RecursivelyReplaceNullWithUndefined<T> = T extends null
  ? undefined
  : T extends Date
  ? T
  : {
      [K in keyof T]: T[K] extends (infer U)[]
        ? RecursivelyReplaceNullWithUndefined<U>[]
        : RecursivelyReplaceNullWithUndefined<T[K]>;
    };

export const nullsToUndefined = <T>(
  obj: T
): RecursivelyReplaceNullWithUndefined<T> => {
  if (obj === null || obj === undefined) {
    return undefined as any;
  }

  // object check based on: https://stackoverflow.com/a/51458052/6489012
  if (obj.constructor.name === "Object") {
    for (let key in obj) {
      obj[key] = nullsToUndefined(obj[key]) as any;
    }
  }
  return obj as any;
};

Now, on all my Pothos resolvers, I wrap the args in this nullsToUndefined function, like so:

builder.mutationFields((t) => ({
  create: t.field({
    type: UserType,
    args: {
      email: t.arg.string({ required: true }),
      phone: t.arg.string(),
    },
    resolve: async (_, args) => userEntityCreate(nullsToUndefined(args)),
  }),
}));

It saves a lot of work and messiness in my business logic; would recommend!

Posting this as an idea because it'd be nice to not have to use this wrapper in the first place, and have an additional option analogous to nullable called undefinable. Then, nullable would only specify that null is allowed, not necessarily both null and undefined, and undefinable would only specify that undefined is allowed, not necessarily both null and undefined. But as an intermediate solution, using a wrapper like this works well!