I wrapped the Resolver decorator of @nestjs/graphql to add some additional functionality. My code looks like this:

import {
  Resolver as GraphQLResolver,
  ResolverOptions,
  ResolverTypeFn,
} from '@nestjs/graphql';

function instanceOfResolverOptions(object: any): object is ResolverOptions {
  return typeof object === 'object' || 'isAbstract' in object;
}

export function Resolver(
  nameOrTypeOrOptions:
    | string
    | ResolverTypeFn
    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
    | Function
    | ResolverOptions,
  options?: ResolverOptions,
): ClassDecorator {
  return function (target) {
    if (nameOrTypeOrOptions instanceof Function) {
      GraphQLResolver(nameOrTypeOrOptions, options)(target);
    } else if (typeof nameOrTypeOrOptions === 'string') {
      GraphQLResolver(nameOrTypeOrOptions)(target);
    } else if (instanceOfResolverOptions(nameOrTypeOrOptions)) {
      GraphQLResolver(nameOrTypeOrOptions)(target);
    } else {
      GraphQLResolver()(target);
    }
  };
}

It fits my needs, but why will the following not work:

import {
  Resolver as GraphQLResolver,
  ResolverOptions,
  ResolverTypeFn,
} from '@nestjs/graphql';

function instanceOfResolverOptions(object: any): object is ResolverOptions {
  return typeof object === 'object' || 'isAbstract' in object;
}

export function Resolver(
  nameOrTypeOrOptions:
    | string
    | ResolverTypeFn
    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
    | Function
    | ResolverOptions,
  options?: ResolverOptions,
): ClassDecorator {
  return function (target) {
    if (nameOrTypeOrOptions instanceof Function) {
      GraphQLResolver(nameOrTypeOrOptions, options)(target);
    } else if (
      typeof nameOrTypeOrOptions === 'string' ||
      instanceOfResolverOptions(nameOrTypeOrOptions)
    ) {
      GraphQLResolver(nameOrTypeOrOptions)(target);
    } else {
      GraphQLResolver()(target);
    }
  };
}

This will result in the following error:

resolver.decorators.ts:27:23 - error TS2769: No overload matches this call.
2025-04-01T08:01:12.892466843Z   The last overload gave the following error.
2025-04-01T08:01:12.892477052Z     Argument of type 'string | ResolverOptions' is not assignable to parameter of type 'ResolverTypeFn'.
2025-04-01T08:01:12.892478427Z       Type 'string' is not assignable to type 'ResolverTypeFn'.
2025-04-01T08:01:12.892479343Z 
2025-04-01T08:01:12.892480093Z 27       GraphQLResolver(nameOrTypeOrOptions)(target);
2025-04-01T08:01:12.892481052Z                          ~~~~~~~~~~~~~~~~~~~
2025-04-01T08:01:12.892481927Z 
2025-04-01T08:01:12.892482635Z   node_modules/@nestjs/graphql/dist/decorators/resolver.decorator.d.ts:43:25
2025-04-01T08:01:12.892483677Z     43 export declare function Resolver(typeFunc: ResolverTypeFn, options?: ResolverOptions): MethodDecorator & ClassDecorator;
2025-04-01T08:01:12.892484802Z                                ~~~~~~~~
2025-04-01T08:01:12.892485677Z     The last overload is declared here.

Both should be equal but it seems that TypeScript doesn't recognize this. Is this a normal behaviour of TypeScript or am I doing something wrong?

I wrapped the Resolver decorator of @nestjs/graphql to add some additional functionality. My code looks like this:

import {
  Resolver as GraphQLResolver,
  ResolverOptions,
  ResolverTypeFn,
} from '@nestjs/graphql';

function instanceOfResolverOptions(object: any): object is ResolverOptions {
  return typeof object === 'object' || 'isAbstract' in object;
}

export function Resolver(
  nameOrTypeOrOptions:
    | string
    | ResolverTypeFn
    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
    | Function
    | ResolverOptions,
  options?: ResolverOptions,
): ClassDecorator {
  return function (target) {
    if (nameOrTypeOrOptions instanceof Function) {
      GraphQLResolver(nameOrTypeOrOptions, options)(target);
    } else if (typeof nameOrTypeOrOptions === 'string') {
      GraphQLResolver(nameOrTypeOrOptions)(target);
    } else if (instanceOfResolverOptions(nameOrTypeOrOptions)) {
      GraphQLResolver(nameOrTypeOrOptions)(target);
    } else {
      GraphQLResolver()(target);
    }
  };
}

It fits my needs, but why will the following not work:

import {
  Resolver as GraphQLResolver,
  ResolverOptions,
  ResolverTypeFn,
} from '@nestjs/graphql';

function instanceOfResolverOptions(object: any): object is ResolverOptions {
  return typeof object === 'object' || 'isAbstract' in object;
}

export function Resolver(
  nameOrTypeOrOptions:
    | string
    | ResolverTypeFn
    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
    | Function
    | ResolverOptions,
  options?: ResolverOptions,
): ClassDecorator {
  return function (target) {
    if (nameOrTypeOrOptions instanceof Function) {
      GraphQLResolver(nameOrTypeOrOptions, options)(target);
    } else if (
      typeof nameOrTypeOrOptions === 'string' ||
      instanceOfResolverOptions(nameOrTypeOrOptions)
    ) {
      GraphQLResolver(nameOrTypeOrOptions)(target);
    } else {
      GraphQLResolver()(target);
    }
  };
}

This will result in the following error:

resolver.decorators.ts:27:23 - error TS2769: No overload matches this call.
2025-04-01T08:01:12.892466843Z   The last overload gave the following error.
2025-04-01T08:01:12.892477052Z     Argument of type 'string | ResolverOptions' is not assignable to parameter of type 'ResolverTypeFn'.
2025-04-01T08:01:12.892478427Z       Type 'string' is not assignable to type 'ResolverTypeFn'.
2025-04-01T08:01:12.892479343Z 
2025-04-01T08:01:12.892480093Z 27       GraphQLResolver(nameOrTypeOrOptions)(target);
2025-04-01T08:01:12.892481052Z                          ~~~~~~~~~~~~~~~~~~~
2025-04-01T08:01:12.892481927Z 
2025-04-01T08:01:12.892482635Z   node_modules/@nestjs/graphql/dist/decorators/resolver.decorator.d.ts:43:25
2025-04-01T08:01:12.892483677Z     43 export declare function Resolver(typeFunc: ResolverTypeFn, options?: ResolverOptions): MethodDecorator & ClassDecorator;
2025-04-01T08:01:12.892484802Z                                ~~~~~~~~
2025-04-01T08:01:12.892485677Z     The last overload is declared here.

Both should be equal but it seems that TypeScript doesn't recognize this. Is this a normal behaviour of TypeScript or am I doing something wrong?

• typescript

1 Answer 1

The problem is TS matches arguments strictly against the overloaded signatures only, since there's no overloaded signature with string | ResolverOptions, only the first case with 2 if blocks is valid unfortunately. You could create a wrapper function to ease the situation if needed:

Playground

function foo(arg: string): string;
function foo(arg: object): string;
function foo(arg: string | object): string {
  return '';
}

const arg = 'foo' as string | object;
foo(arg); // No overload matches this call.

const wrapper = (arg: string | object): string => typeof arg === 'string' ? foo(arg): foo(arg);
wrapper(arg);

But you have a problem with your function call signature in the first place. For example you could provide options argument when it's not needed especially when nameOrTypeOrOptions is already ResolverOptions. So I suggest to fix your function arguments first. One way would be provide a proper set of arguments to call GraphQLResolver and just call it unsafely inside the function body (you could elaborate it to call GraphQLResolver safely but safe arguments are already provided:

Playground

export function Resolver(...args:
  [name: string] | [func: Function | ResolverTypeFn, options?: ResolverOptions] | [options: ResolverOptions] | []
): ClassDecorator {
  return function (target) {
      (GraphQLResolver as any)(...args)(target);
  };
}

As a bonus you'd have a nice autocomplete:

Also you could use overloading but it's more verbose:

export function Resolver(name: string): ClassDecorator;
export function Resolver(func: Function | ResolverTypeFn, options?: ResolverOptions): ClassDecorator;
export function Resolver(options: ResolverOptions): ClassDecorator;
export function Resolver(): ClassDecorator;

export function Resolver(...args: any[]): ClassDecorator {
  return function (target) {
    (GraphQLResolver as any)(...args)(target);
  };
}