How to type a method with an interface as parameter

Question

I'm trying to define a method signature where a parameter should conform to an interface.

interface Command {}

class HelloCommand implements Command {
  constructor(public readonly name: string) {}
}

type HandleCommandFn = (command: Command) => Promise<any>;

const handleHello: HandleCommandFn = (
  command: HelloCommand
): Promise<string> => {
  return Promise.resolve(`Hello ${command.name}`);
};

I get the following error from the compiler:

src/index.ts:9:7 - error TS2322: Type '(command: HelloCommand) => Promise<string>' is not assignable to type 'HandleCommandFn'.
  Types of parameters 'command' and 'command' are incompatible.
    Property 'name' is missing in type 'Command' but required in type 'HelloCommand'.

9 const handleHello: HandleCommandFn = (

I also tried the following variations :

type HandleCommandFn = <C extends Command>(command: C) => Promise<any>;

type HandleCommandFn = <C extends Command = Command>(command: C) => Promise<any>;

UPDATE

With the help of answers below, I managed to get the following piece of code (my goal was to define a type-safe method decorator) :

interface Command {
  getDescription(): string;
}

type HandleCommandFn<C extends Command = Command> = (
  command: C
) => Promise<any>;

function HandleCommand<C extends Command = Command>(
  target: Object,
  propertyKey: string | symbol,
  descriptor: TypedPropertyDescriptor<HandleCommandFn<C>>
): void {
  const method = descriptor.value;
  if (method) {
    // Do something
  }
}

class HelloCommand implements Command {
  constructor(public readonly name: string) {}

  public getDescription(): string {
    return "Say hello";
  }
}

class HelloCommandHandler {
  @HandleCommand // OK
  public execute(command: HelloCommand): Promise<string> {
    return Promise.resolve(`Hello ${command.name}`);
  }

  @HandleCommand // Error (wrong parameter type)
  public execute2(command: string): Promise<string> {
    return Promise.resolve(`Hello ${command}`);
  }

  @HandleCommand // Error (wrong return type)
  public execute3(command: HelloCommand): string {
    return `Hello ${command.name}`;
  }
}

score 2 · Accepted Answer · answered Sep 14 '21 at 08:11

2

This should work

interface Command {}

class HelloCommand implements Command {
    constructor(public readonly name: string) {}
}

type HandleCommandFn<C extends Command = Command> = (
    command: C
) => Promise<any>;

const handleHello: HandleCommandFn<HelloCommand> = (
    command
): Promise<string> => {
    return Promise.resolve(`Hello ${command.name}`);
};

answered Sep 14 '21 at 08:11

Sri

242
3
13

I can confirm this works. My goal was to define a type-safe method decorator. I updated the question with the complete working code. – Sylvain Desvé Sep 14 '21 at 11:25

score 1 · Answer 2 · answered Sep 14 '21 at 09:43

This is because function arguments are contravariant. Consider this example:

interface Command { }

interface HelloCommand extends Command {
  name: string
}

declare var command: Command

declare var helloCommand: HelloCommand

command = helloCommand // ok , is assignable

It is intuitively, helloCommand is assignable to command because it is more specific. And it is easy to understand why subtype is assignable to supertype.

But if you look at this example, things are not obvious anymore:

let commandFn = (command: Command) => void 0

let helloCommandFn = (command: HelloCommand) => void 0

commandFn=helloCommandFn // error, is not assignable anymore

FUnction with HelloCommand argument (subtype of Command) is not assignable anymore to function with Command (supertype).

This is how contravariance works. Direction of inheritance has changed is opposite direction. What you are trying to do is unsafe, or in other words - unsound behavior.

In order to trick compiler you can add extra generic:

type HandleCommandFn<T extends Command> = <U extends HelloCommand>(command: T & U) => Promise<any>;

// ok
const handleHello: HandleCommandFn<Command> = (
  command
): Promise<string> => {
  return Promise.resolve(`Hello ${command.name}`);
};

Many thanks for your answer which pointed me to the following article : https://medium.com/@michalskoczylas/covariance-contravariance-and-a-little-bit-of-typescript-2e61f41f6f68 I was bot familiar with covariance and contravariance, I now understand it. — Sylvain Desvé, Sep 14 '21 at 11:14
Please check my question and all related links https://stackoverflow.com/questions/66410115/difference-between-variance-covaraince-contravariance-and-bivariance-in-typesc . You will find a lot more information — captain-yossarian from Ukraine, Sep 14 '21 at 11:18

How to type a method with an interface as parameter

2 Answers2