扩展 TypeScript 声明文件

Question

I am trying to work with TypeScript and Express. I've loaded in the type declarations from Typings and they look like this:

// Generated by typings
// Source: https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/7de6c3dd94feaeb21f20054b9f30d5dabc5efabd/express/express.d.ts
declare module "express" {
    import * as serveStatic from "serve-static";
    import * as core from "express-serve-static-core";

    /**
     * Creates an Express application. The express() function is a top-level function exported by the express module.
     */
    function e(): core.Express;

    namespace e {

        /**
         * This is the only built-in middleware function in Express. It serves static files and is based on serve-static.
         */
        var static: typeof serveStatic;

        export function Router(options?: any): core.Router;

        interface Application extends core.Application { }
        interface CookieOptions extends core.CookieOptions { }
        interface Errback extends core.Errback { }
        interface ErrorRequestHandler extends core.ErrorRequestHandler { }
        interface Express extends core.Express { }
        interface Handler extends core.Handler { }
        interface IRoute extends core.IRoute { }
        interface IRouter<T> extends core.IRouter<T> { }
        interface IRouterMatcher<T> extends core.IRouterMatcher<T> { }
        interface MediaType extends core.MediaType { }
        interface NextFunction extends core.NextFunction { }
        interface Request extends core.Request { }
        interface RequestHandler extends core.RequestHandler { }
        interface RequestParamHandler extends core.RequestParamHandler { }
        export interface Response extends core.Response { }
        interface Router extends core.Router { }
        interface Send extends core.Send { }
    }

    export = e;
}

Now I'm trying to extend the prototype for all Response objects like so:

const express = require('express');
express.response.sendWrapped = function(obj: Object, meta?: Object) {
    return this.json({
        data: obj
    });
};

Now I just need to get the extension into the typings. I would love to just extend this method into the existing definition, much like how I have extended it in the prototype, but I am unsure how to do so.

Since this is a personal extension of the type definition for the library, I do not believe this belongs back with the master typing set and I should not have to modify them manually for my own purposes. What is the best way to extend them in my own way? Can I do it without overriding every other piece dependent on Response?

Answer 1

Using TypeScript 2.0 or a pre-release of it ( typescript@next ) you can use module augmentation syntax to augment the definition of express to include your new response definition:

 import express = require('express'); declare module "express" { namespace response { function sendWrapped(obj: any, meta?: any): void; } } express.response.sendWrapped = function(obj: Object, meta?: Object) { return this.json({ data: obj }); };

Answer 2

A few things:

(1) There's no response in the declarations you included, there's a Response , so it should be: express.Response.sendWrapped .

(2) You did not extend the prototype for all Response s, you added the sendWrapped function to the class itself (I assume that Response is a class).
If you want to add to the prototype it should look like:

express.Response.prototype.sendWrapped = function(obj: Object, meta?: Object) {
    return this.json({
        data: obj
    });
};

(3) You can add to an existing type like so:

namespace express {
    interface Response {
        sendWrapped(obj: Object, meta?: Object): any;
    }
}

More about that in Declaration Merging

---

Edit

If it's in a d.ts file then you need it to be:

declare namespace express {
    ...
}

I'm not sure why it doesn't let you merge declarations and I don't have this setup to test it on my own, but I have another solution for you which is, in my opinion, better.

Just extend express.Response add what ever you need in there, for example:

class MyResponse extends express.Response {
    constructor() {
        super();
    }

    sendWrapped(obj: Object, meta?: Object): express.Response {
        return this.json({
            data: obj
        });
    }
}

This is better because you're not as vulnerable for changes in the express api, and more than that, this is what object oriented is for.