Express's Middleware type

In my app, I’m using following error handler, which would break in case of err === null. Why is the error parameter allowed to be null in Middleware type?

export default function errorHandler(err, req, res, next) {
  const errorDetails = err.stack || err;
  ...
}

I would rather see something like this:

declare type NextFunction = () => mixed;
declare type NextFunctionWithError = (err?: Error) => mixed;
declare type Middleware =
    ((req: Request, res: Response, next: NextFunction) => mixed) |
    ((error: Error, req : Request, res: Response, next: NextFunctionWithError) => mixed);

What do you think?

[bassettsj]

Hmmm… this is a tough one. I think you could improve this by making sure to define that class as extending the base class and make sure that you add the type definitions for them to middleware functions:

// @flow
const app = express();
app.use(session(...));
declare class session$Request, extends express$Request {
    session: { [key: string]: mixed };
}

app.use((req: session$Request, res: express$Response, next: express$NextFunction): void => {
  req.session.user = { id: 2 };
  next();
});

I think we will probably have to add parameterization to the lib defs, but I am not sure what the best way to do this. We should look to see how definitely-typed accomplished this and see if we could follow their lead.

[jtlapp]

I’ll have to look at your #508 mod more closely. I’ve pulled out most of my app-specific stuff, so you can see how I did the wrapping:

// @flow

/******************************************************************************
Express request/response extensions and supporting wrapper classes.
******************************************************************************/

var express = require('express');

/*::
declare class _SessionRequest extends express$Request
{
    // custom extensions
    
    userInfo: {
        userID: number;
        displayName: string;
        privileges: string;
    };
    
    // request internals
    
    connection: {
        remoteAddress: string;
    };
    requestTimeUTC: number;
}

declare class _SessionResponse extends express$Response
{
    // custom extensions
    
    sessionState: any; // replace 'any' with your custom representation
}

// adapted from express$NextFunction
declare type _SessionNext = (err: ?ErrnoError) => void;

// adapted from express$Middleware
declare type _SessionMiddleware =
    ((req: _SessionRequest, res: _SessionResponse, next: _SessionNext)
        => mixed) |
    ((err: ErrnoError, req: _SessionRequest, res: _SessionResponse,
        next: _SessionNext) => mixed);

declare interface _SessionRouteMethodType<T>
{
    // adapted from express$RouteMethodType
    (middleware: _SessionMiddleware, ...extra: Array<_SessionMiddleware>): T;
    (path: string|RegExp|string[], ...middleware: Array<_SessionMiddleware>): T;
}

declare interface _SessionRouterMethodType<T>
{
    // adapted from express$RouterMethodType
    (middleware: _SessionMiddleware, ...extra: Array<_SessionMiddleware>): T;
    (path: string|RegExp|string[], ...middleware: Array<_SessionMiddleware>): T;
    (path: string, router: _SessionRouter): T;
}

declare class _SessionRouter
{
    // adapted from express$Route and express$Router
    constructor(options?: express$RouterOptions): void;
    all: _SessionRouteMethodType<this>;
    get: _SessionRouteMethodType<this>;
    post: _SessionRouteMethodType<this>;
    put: _SessionRouteMethodType<this>;
    head: _SessionRouteMethodType<this>;
    delete: _SessionRouteMethodType<this>;
    use: _SessionRouterMethodType<this>;
}

declare class _SessionApplication extends _SessionRouter
{
    // adapted from express$Application
    constructor(): void;
    locals: {[name: string]: mixed};
    mountpath: string;
    listen(port: number, hostname?: string, backlog?: number, callback?: _SessionNext): Server;
    listen(port: number, hostname?: string, callback?: _SessionNext): Server;
    listen(port: number, callback?: _SessionNext): Server;
    listen(path: string, callback?: _SessionNext): Server;
    listen(handle: Object, callback?: _SessionNext): Server;
    disable(name: string): void;
    disabled(name: string): boolean;
    enable(name: string): void;
    enabled(name: string): boolean;
    engine(name: string, callback: Function): void;
    // FlowType does not allow get() to be declared
    // get(name: string): mixed;
    set(name: string, value: mixed): mixed;
    render(name: string, optionsOrFunction: {[name: string]: mixed}, callback: express$RenderCallback): void;
}
*/

class RouterWrapper
{
    // largely calls router via apply(), so the type doesn't matter
    /*:: router: any; */
    
    constructor(options, router) {
        if (router)
            this.router = router;
        else
            this.router = express.Router(options);
    }
    
    use(/*arguments*/) {
        // Apps only call use() at initialization, so it's okay to have a
        // heavy implementation. Express requires its own router type.
        
        let args = Array.prototype.slice.call(arguments);
        for (let i = 0; i < args.length; ++i) {
            if (args[i] instanceof RouterWrapper)
                args[i] = args[i].router;
        }
        return this.router.use.apply(this.router, args);
    }
    
    get(/*arguments*/) {
        return this.router.get.apply(this.router, arguments);
    }
    
    post(/*arguments*/) {
        return this.router.post.apply(this.router, arguments);
    }
    
    put(/*arguments*/) {
        return this.router.put.apply(this.router, arguments);
    }
    
    delete(/*arguments*/) {
        return this.router.delete.apply(this.router, arguments);
    }
}

class AppWrapper extends RouterWrapper
{
    constructor() {
        super(null, express());
    }
    
    listen() {
        return this.router.listen.apply(this.router, arguments);
    }
        
    disable(name) {
        this.router.disable(name);
    }
    
    disabled(name) {
        return this.router.disabled(name);
    }
    
    enable(name) {
        this.router.enable(name);
    }
    
    enabled(name) {
        return this.router.enabled(name);
    }
    
    engine(name, callback) {
        this.router.engine(name, callback);
    }
    
    /*
    // TBD: add support for this additional signature. The base router uses
    // get() only as an HTTP method.
    get(name) {
        return this.router.get(name);
    }
    */
    
    set(name, value) {
        return this.router.set(name, value);
    }
    
    render(name, optionsOrFunction, callback) {
        this.router.render(name, optionsOrFunction, callback);
    }
}

//// EXPORTS //////////////////////////////////////////////////////////////////

/*::

// The $-prefixed variables correspond to their namesake Express objects.

export type $Application = _SessionApplication;
export type $Router = _SessionRouter;
export type $Request = _SessionRequest;
export type $Response = _SessionResponse;

// NextFunc defines the callback that Express "middleware" handlers use.

export type NextFunc = _SessionNext;

// StackHandler provides the usual signature for a "middleware" handler.

export type StackHandler =
        (req: $Request, res: $Response, next: NextFunc) => void;

// FormFields generically defines the value of req.body when populated by an HTML input field. Only use this when the input field names are dynamic. If the names can be hardcoded, instead define them as a specific type of object.

export type FormFields = { [key: string]: string };
*/

exports = module.exports = function () /*:$Application*/
{
    return ((new AppWrapper() /*:any*/) /*:$Application*/);
};

    
exports.static = function (root /*:string*/, options /*?:Object*/)
        /*:_SessionMiddleware*/
{
    return express.static(root, options);
}

exports.Router = function (options /*?:express$RouterOptions*/) /*:$Router*/
{
    return ((new RouterWrapper(options) /*:any*/) /*:$Router*/);
};