Error when calling listen on Node's http server

[ntharim]

flow has support for Node's http module. However calling listen on a Server instance causes an error that shouldn't exist. Given the following code:

import http from 'http';

const server = http.createServer(() => {});
server.listen(3000, () => {});

The error is:

call of method `listen`
Function cannot be called on any member of intersection type

You can see this on tryflow.org:
http://tryflow.org/#6b0a9f9d52c7320c9e9de182fa081c55

[yinanfang]

I have the same problem as well! Why there's no one looking at this problem? @nthtran

[bakotaco]

@nthtran FYI the link you provided (http://tryflow.org/#6b0a9f9d52c7320c9e9de182fa081c55) does not illustrate the error (anymore)

[bakotaco]

the issue seems to be that the http.Server.listen method is defined as follows:

listen(port: number, hostname?: string, backlog?: number, callback?: Function): Server;

So if there is a second argument provided to listen flow will assume this is the hostname parameter, however the provided callback Function does not match the expected string type. There is also a second definition:

listen(path: string, callback?: Function): Server;

Which does expect the second parameter to be a Function, but does not match as the first provided argument is a number.

You could 'solve' this by explicitly provided undefined as arguments for the listen call, e.g.:

server.listen(3000, undefined, undefined, () => {});

[yinanfang]

@bakotaco That solved my problem! THANKS!
Most of the express documentations are doing something like server.listen(3000, () => {}); and I just overlooked the [backlog] there.

[jedwards1211]

@mroch ugly as hell but this definition seems to work:

declare var listen:
  ((port?: number, hostname?: string, backlog?: number, callback?: Function) => void) &
  ((port?: number, hostname?: string, callback?: Function) => void) &
  ((port?: number, backlog?: number, callback?: Function) => void) &
  ((port?: number, callback?: Function) => void) &
  ((hostname?: string, backlog?: number, callback?: Function) => void) &
  ((hostname?: string, callback?: Function) => void) &
  ((backlog?: number, callback?: Function) => void) &
  ((callback?: Function) => void)

The downside is that the error messages are loooooooong. Should I make a PR or no?

Alternatively, assuming that invalid arguments will just be ignored by the implementation, perhaps it would be best to change the signature to just Function for now

[jedwards1211]

@mroch proposal: use ?? for arguments that can be omitted even if following arguments are included. So for example a function with some optional arguments that requires a callback as last argument:

declare module fs {
  declare function writeFile(
    file: string | Buffer | number, 
    data: string | Buffer, 
    options??: Object | string, 
    callback?: (err: ?ErrnoError) => void
  ): void;
}