Request: import module types without calling import x = require('x')

[jt000]

I am investigating how to mock node.js dependencies and it has stemmed to a couple issues.

1. Cannot call var http = require('http') and have compile time support of http (it will always be "any")
2. Cannot call import http = require('http') anytime except in the top-most level of a module.

What I would like to do is get compile time support of a module without calling require. For example, maybe something like the below code...

import http = /* typeLoad('http') - get type information without creating any code in JS for compile time support */;
export class Webhost {
    start(): http.Server {
        /* actually get the require definition for 'http' here */
        var httpDef: /* module 'http' */ = require('http');
        return httpDef.createServer();
    }
}

This would allow me to have some compiler support for types and functions, but would allow me to delay actually getting the object in order to allow me to mock it in tests. This could also be used to create dependency injection methods like:

// web.ts
export class Webhost {
    httpDef: /* module 'http' */
    constructor(httpDef: /* module 'http' */ = require('http') /* default to require */) {
        this.httpDef = httpDef;
    }

    start(): http.Server {
        return this.httpDef.createServer();
    }
}

// test.ts
var mockHttpServer: /* module 'http' */ = {
    createServer: () => console.log('server created');
};

import web = require('./web');
var webHost = new web.Webhost(mockHttpServer);

Note: This might be specific to how node.d.ts is implemented since the modules are declared with declare module "http" {...}

[jt000]

Nevermind... After looking through the documentation I stumbled onto the advanced loading of modules and found that one can use typeof html to reference the module itself.

I was able to update the above to support my scenarios as the following:

import httpDef = require('http');
export class Webhost {
    start(): httpDef.Server {
        /* actually get the require definition for 'http' here */
        var http: typeof httpDef = require('http');
        return http.createServer();
    }
}

It would be nice if there was a way to ensure that the first require('http') didn't create any JS code using a different syntax or something, but not something that can't be fixed with some extra unit tests.

The 2nd scenario also works using the typeof trick...

// web.ts
import httpDef = require('http');
export class Webhost {
    http: typeof httpDef;
    constructor(http: typeof httpDef = require('http')) {
        this.httpDef = httpDef;
    }

    start(): httpDef.Server {
        return this.http.createServer();
    }
}

// test.ts
import httpDef = require('http');
var mockHttp: typeof httpDef = <typeof httpDef>{
    createServer: () => {
        console.log('server created');
        return mockHttp;
    }
};

import web = require('./web');
var webHost = new web.Webhost(mockHttp);

Case closed... 👍

[NoelAbrahams]

@jt000, have you considered something like Sandboxed-Module for your scenario? The benefit is there is no need to have two require calls per import.

I'd be interested to know what you think.