I'm getting my head around Node, Express and TypeScript, in doing so I'm looking to build up some tests.
To follow best practices, SOLID etc I've separated my routers from my controllers.
I have an index.ts file
import { Router } from 'express';
import { TestController } from '../controllers/test.controller';
let testController = new TestController();
let index = Router();
/* GET home page. */
index.get('/', (req, res, next) => testController.get(req, res));
export default index;
I also have an index.spec.ts file
import assert = require('assert');
import * as mocha from 'mocha';
import { index } from '../routes/index';
import { TestController } from '../controllers/test.controller';
import { Request, Response } from 'express';
var sinon = require('sinon');
var should = require('should');
import app from '../App';
describe('Indexrouter', function () {
describe('#Calling get /', function () {
it('should call test controller get function.', function () {
});
});
});
When I try and run the tests via gulp i get the following messages
"D:/Dev/Learning/node/ts-express/src/routes/index.ts(4,7): Exported variable 'index' has or is using name 'Router' from external module \"express-serve-static-core\" but cannot be named."
"D:/Dev/Learning/node/ts-express/src/routes/index.spec.ts(4,10): Module '\"D:/Dev/Learning/node/ts-express/src/routes/index\"' has no exported member 'index'."
"D:/Dev/Learning/node/ts-express/src/app.ts(24,14): Cannot find name 'index'."
I can run the server ok and it will produce the correct endpoint with response. Although I do get the working about exported variable 'index'. It just seems that in the tests I can't import the index module for some reason.
How can I fix the module so I don't get the exported variable error.
How can I actually test that the index route calls the get method on the controller.
I have managed to get the controller tests working and the project as a whole can be seen here
Related
I'm new in nodejs, I'm using fastify and I want to be able to use the req.logger in all the classes functions of the flow, this because I have a the request-id on req.logger, the first solution that came to my mind is to pass as a parameter the logger through all the function/classes but I think that would make the code kind of dirty, here is an example of my code:
app.ts
import pino from 'pino';
import fastify from 'fastify';
declare module 'fastify' {
interface FastifyInstance {
// augment fastify instance with the config object types
config: Config;
}
}
function build() {
const app = fastify({
logger: pino({
name: process.env.NAME,
level: process.env.LOG_LEVEL,
}),
disableRequestLogging: true,
requestIdHeader: 'correlation-id',
requestIdLogLabel: 'correlationId',
});
// register plugins
app.register(apiRoutes, fastify => ({
getObjectUseCase: new GetObjectUseCase(
new TestClass()),
}));
return app;
}
export { build };
routes.ts
import { FastifyPluginCallback } from 'fastify';
import { StatusCodes } from 'http-status-codes';
export const apiRoutes: FastifyPluginCallback<RoutesOpts> = async (fastify, options, done) => {
const getObjectUseCase = options.getObjectUseCase;
fastify.get<object>('/v1/api/:id', async (req, reply) => {
const id = req.params.payoutId;
req.logger.info('This is a logger print'); // has the correlation id inside it while printing
const storedObject = await getObjectCase.execute(id);
reply.code(StatusCodes.OK).send(storedObject);
});
}
GetObjectUseCase.ts
export class GetObjectUseCase {
private anotherClass: TestClass;
constructor(anotherClass: TestClass) {
this. anotherClass = anotherClass;
}
async execute(id: string): Promise<StoredObject> {
// I want to use the logger here with have the correlation id on it without having to pass it as an argument on the method, how is it posible?
return this.anotherClass.getById(id);
// also needed to use it inside anotherClass.getById so I will need to pass the logger also in the method
}
}
Hope I have been clear.
Thanks!
This may not be the best or only way to do it, but this has worked for me in the past.
Typically I structure my projects with an app.ts that just instantiates my FastifyInstance and then exports the log from that created instance. This allows me to use the log where ever I want to.
It looks something like this.
app.ts
import fastify from 'fastify';
const app = fastify({ logger: true /* Your logging configuration */});
export default app;
export const logger = app.log; // Allows me to log where ever I want.
server.ts
import app from './app';
... // All your fastify configuration and other stuff.
app.listen({ ... });
Now I can use the logger outside of fastify stuff.
get-object-use-case.ts
import { logger } from './app'; // Import your fastify logger to use in this class.
export class GetObjectUseCase {
private anotherClass: TestClass;
constructor(anotherClass: TestClass) {
this. anotherClass = anotherClass;
}
async execute(id: string): Promise<StoredObject> {
logger.info({/* Whatever you want to log here. */}); // Now you can use the logger here.
return this.anotherClass.getById(id); // You can just import the logger into the TestClass file to get logging enabled there.
}
}
This even allows you to log before your FastifyInstance is started. Check out this codesandbox for a running example.
I want to setup morgan-boddy as a midldleware to log requests and responses.
So I've created a function like that:
export function RequestLogging(app) {
const logger = new Logger('Request');
app.use(
morganBody(app, {
stream: { // <--- error is here "Void function return value is used "
write: (message) => logger.log(message.replace('\n', '')),
},
}),
);
}
That I call on main.ts
// main.ts
async function bootstrap() {
const app = await NestFactory.create(AppModule);
useRequestLogging(app);
// ...
}
However it seems does not work. I've got an error 'Void function return value is used' on line stream: {
Any idea how to fix?
UPDATE:
I tried to go different path and actually just stick morganBody in to main.ts as per docs:
import bodyParser from 'body-parser';
import morganBody from 'morgan-body';
app.use(bodyParser.json());
// hook morganBody to express app
morganBody(app); <-- getting error here "TS2345: Argument of type 'INestApplication' is not assignable to parameter of type 'Application'."
I wish there was a proper documentation how to approach in nestjs.
This is a pretty interesting middleware. It ends up needing the express instance itself because it calls app.use(morgan) and app.response.send() under the hood. I would really look into some other solution instead of something that accesses the response in this way.
Either way: this set up works
import { Logger } from '#nestjs/common';
import { NestFactory } from '#nestjs/core';
import * as morgan from 'morgan-body';
import { AppModule } from './app.module';
async function bootstrap() {
const app = await NestFactory.create(AppModule);
const logger = app.get(Logger);
(morgan as any)(app.getHttpAdapter().getInstance(), {
stream: {
write: (message: string) => {
logger.log(message.replace('\n', ''));
return true;
},
},
});
await app.listen(3033);
}
bootstrap();
The types for the package are wrong as well, it's not a default export, but a named one, so import morgan from 'morgan-body' doesn't work as advertised (at least it didn't for me).
The return true is necessary because write expects a stream.writable() method, which has returns a boolean. You can just default this to true. Then you have to use app.getHttpAdapter().getInstance() so that you ensure you pass the express instance to the middleware. Again, wonky setup, but it works.
Converting my Express app to Koa...
I'm googling and I'm googling, I can't find how to pass extra params into Koa middleware. For example...
router.post('/', compose([
Midware.verifyAuthToken,
Midware.bodySchemaTest(UserController.bodyAttribs),
Midware.injectionTest
]), UserController.postNew);
I need send some variable bodyAttribs (string array) names into the bodySchemaTest middleware and I don't know how to do this in Koa.
I'm just now trying Koa. Please share your expertise :-)
Ok I worked it out myself. Not sure if this is smart or the "right" way to do this but the solution for me was to create a piece of middleware in each controller that sets expected schema attribs in ctx.state.bodyAttribs.
Like this...
// /src/routers/user.router.ts
import * as UserController from '../controller/user.controller';
import * as Midware from './middleware';
import Router from 'koa-router';
import compose from 'koa-compose';
const router = new Router();
router.prefix('/user');
router.get('/', Midware.verifyAuthToken, UserController.getAll);
router.post('/', compose([
UserController.bodyAttribs,
Midware.verifyAuthToken,
Midware.bodySchemaTest,
Midware.injectionTest,
]), UserController.postNew);
module.exports = router;
// /src/controller/user.controller.ts
import { Context } from 'koa';
import { UserData } from '../data/mongo/user.data.mongo';
import { UserModel } from '../model/user.model';
import { EmailValidate } from '../service/email-validate.service';
import * as Logger from '../util/logger';
const dataContext = new UserData();
// Middleware to set bodyAttribs
export const bodyAttribs = async (ctx: Context, next: any) => {
ctx.state.bodyAttribs = ['handle', 'processUserOptions', 'name', 'email', 'pass', 'passConfirm'];
return await next();
};
...
So each controller provides the custom middleware that set the custom bodyAttribs I want to verify. You can use this approach to set and pass 1 to any number of extra params, whatever you need, in ctx.state which always goes on to next middleware in chain. Follow? :-)
I'm running into problems with typescript during unit testing. I try to unit test an module like the following code example:
import {Express} from 'express'
export interface BootClassInterface {
setup(): Express
}
export class BootClass implements BootClassInterface {
constructor(private express: () => Express ){
}
public test(){
const app = this.express()
app.get("/test", (req, res) => {
res.send("Hello World")
})
return app;
}
}
For testing propose I want to know if express().get() was called and if the first parameter was '/test'. Before I switched to typescript I always used the module sinonJS to spy or stub the functionality so that I could test of a certain dependency was used correctly. Now with Typescript I run into problems with the strict types that I've set in the module. By example:
import * as chai from 'chai'
import 'mocha'
import * as sinon from 'sinon'
import * as express from 'express'
import * as Boot from '../../src/Core/Boot'
const assert = chai.assert
suite('[CORE] unit test /Core/Boot.ts', () => {
let BootClass: Boot.BootClassInterface
setup(() => {
const expressApp = () => {
const app = express()
app.get = sinon.spy()
return app
}
const Services: Boot.BootServicesInterface = { express: expressApp }
BootClass = new Boot.BootClass(Services)
})
test('Do first test', () => {
const app = BootClass.setup()
chai.assert.equal(app.get.called, 1)
})
})
The code example above results in the following Typescript compiling error:
error TS2339: Property 'called' does not exist on type 'ApplicationRequestHandler<Express>'.
I can see why typescript returns this error and somehow it is even obvious. I even know a possible solution where I accept Express as any in the module.
But I'm looking for a more elegant way to be able to spy/stub/mock my dependencies for testing propose, but at the same time have the advantages of strict typing.
AS you have stated you specify Express as the return type on BootClassInterface interface. Therefore app would be considered Express and it will look up its properties instead of your mock.
You can also just cast one property of app as any. Try:
chai.assert.equal((<any>app.get).called, 1)
Or using Sinon type definition:
chai.assert.equal((<SinonSpy>app.get).called, 1)
I have a file config.ts which simply exports a config object:
const config = {
baseURL: <string> 'http://example.com',
};
export default config;
I have another file called methods.ts which imports the config object and exports a function which uses this config object.
import config from './config';
export function someMethod() {
let url = config.baseURL;
...
}
I'm calling this someMethod from inside the express router:
import { someMethod } from '../methods';
router.get('/something', function(req, res, next) {
let x = someMethod();
...
});
when this someMethod is called the config variable is undefined. It seems someMethod can't see the imported data from the same file when it's called later. What would be the correct way to do this?
Node wraps your module in an IIFE called the module wrapper so even though it is global in your module, its actually still local.
If you want to have access to config outside of your module, you'll need to explicitly export it.
function someMethod() {
let url = config.baseURL;
...
}
export { someMethod, config };
If config is actually common to a number of files, you could use Dependency Injection and move config into the file containing your router that needs config.
Change someMethod to accept config
// methods.ts
function someMethod(config) {
let url = config.baseURL;
...
}
export { someMethod };
Import ./config in your router instead and pass config into someMethod
// router
import config from './config'
import { someMethod } from '../methods';
router.get('/something', function(req, res, next) {
let x = someMethod(config);
...
});
I believe you can do
import config from './config';
var Config = config
export function someMethod() { console.log(Config) }