Can't return `null` from nullable filed resolver

[kamilchm]

To Reproduce
Steps to reproduce the behavior:

1. My GraphQL schema:

type Query {
  optional: Result
}
type Result {
  mandatory: String!
}

2. My GraphQL operations:

const resolvers: Resolvers = {
  Query: {
    optional: () => Promise.resolve("x").then(r => (r ? {} : null))
  }
};

Expected behavior
null is a valid result type, but I get:

src/resolvers.ts(4,3): error TS2322: Type '{ optional: () => Promise<Result | Promise<Result> | {} | null>; }' is not assignable to type 'QueryResolvers<MyContext, {}>'.
      Types of property 'optional' are incompatible.
        Type '() => Promise<Result | Promise<Result> | {} | null>' is not assignable to type 'ResolverFn<Maybe<ResolverTypeWrapper<Result>>, {}, MyContext, {}> | StitchingResolver<Maybe<ResolverTypeWrapper<Result>>, {}, MyContext, {}> | undefined'.
          Type '() => Promise<Result | Promise<Result> | {} | null>' is not assignable to type 'ResolverFn<Maybe<ResolverTypeWrapper<Result>>, {}, MyContext, {}>'.
            Type 'Promise<Result | Promise<Result> | {} | null>' is not assignable to type 'Result | Promise<Result> | Promise<Maybe<ResolverTypeWrapper<Result>>> | null'.
              Type 'Promise<Result | Promise<Result> | {} | null>' is not assignable to type 'Promise<Result>'.
                Type 'Result | Promise<Result> | {} | null' is not assignable to type 'Result'.
                  Type 'null' is not assignable to type 'Result'.

Environment:

• OS: Linux
• @graphql-codegen/...: 1.9.1
• NodeJS: 12

[dotansimha]

@kamilkisiela can you please take a look?

[kamilchm]

To be fair, I don't know if it a valid issue here. The produced error comes from TS compiler. In encountered it on a pretty big schema with complex types (tens of fields) and it wasn't easy to spot the real error.
I wonder if there is a place for improvement for generated types, to make compile errors more direct, like it was before introducing ResolverTypeWrapper.

[dotansimha]

@kamilchm I'm closing for now. If you have an idea for improvement feel free to share with us :)

[freshollie]

@dotansimha @kamilchm This issue is related to the way Maybe wraps the ResolverType, instead of the ResolverTypeWapper wrapping the Maybe:

Example:

Schema:

type Query {
  getDraft(id: ID!): Draft,
}

Generated code

export type Maybe<T> = T | null;

export type ResolversTypes = {
  Draft: ResolverTypeWrapper<Draft>,
  ...
}
export type QueryResolvers<...> = {
  getDraft?: Resolver<Maybe<ResolversTypes['Draft']>, ParentType, ContextType, RequireFields<QueryGetDraftArgs, 'id'>>
}

This causes Maybe to wrap Promise<Draft> | Draft and wrongly make the type Promise<Draft> | Draft | null

I think the generated code should instead be

export type ResolversTypes = {
  Draft: ResolverTypeWrapper<Maybe<Draft>>,
  ...
}
export type QueryResolvers<...> = {
  getDraft?: Resolver<ResolversTypes['Draft']>, ParentType, ContextType, RequireFields<QueryGetDraftArgs, 'id'>>
}

This would correctly resolve getDraft to be Promise<Draft | null> | Draft | null

This obviously doesn't work here. As it would mean Draft would always be a maybe, but you can see the real issue in the types generated here right? This has nothing to do with the typescript compiler but the way Maybe is used.

For us right now, the only solution is to resolve the promise before returning the value, but it's a workaround which doesn't seem like it needs to exist.

[freshollie]

Another solution to this could be to change Maybe to better extend Promise types:

export type Maybe<T> = T extends PromiseLike<infer U> ? Promise<U | null> : T | null;

[wallzero]

@dotansimha I think this should be left open. Promises should be able to return null in case of issue.

@freshollie could you share how you are resolving the promise as a work around? I am trying to figure out a solution while keeping type safety.

[freshollie]

@wallzero Adding my solution as the Maybe value fixes this issue.

    plugins:
      - typescript
      - typescript-resolvers
    config:
      ....
      maybeValue: 'T extends PromiseLike<infer U> ? Promise<U | null> : T | null'

[lecstor]

maybeValue: 'T extends PromiseLike ? Promise<U | null> : T | null'

So this didn't fix the issue I was having, but it did make it obvious where the issue was which I was unable to decipher before that.
After I fixed the issue I was able to remove it again.