Nest is a framework for building efficient, scalable Node.js server-side applications.

It uses modern JavaScript, is built with TypeScript (preserves compatibility with pure JavaScript) and combines elements of OOP, FP, and FRP.

• Dependency injection container – NestJS comes with its own DiC, an utility that seems to be forgotten in the JavaScript world but I can’t really live without it. There are a few solutions like Inversify or Bottle but NestJS has its own solution in place. And it supports factory injection too.
• Modularisation – in NestJS every logical part of the application which lives within the same domain boundary is a module and it encourages encapsulation.
• Testability – due to introducing DiC and Modularisation you can build your app pretty much based on services, keeping your controllers thing, which makes it easier to test.
• Written in TypeScript – types are good. They allow you to stop thinking that the thing you’re assigning to a variable is the one that’s needed. It has to be

Prepare the project

node -v

$ git clone https://github.com/nestjs/typescript-starter.git project
$ cd weather-app/

$ npm i
$ npm run start

> [email protected] start /Users/mat/Development/weather-app
> node index.js

[Nest] 31827 - 2018-1-13 11:39:32 [NestFactory] Starting Nest application...
[Nest] 31827 - 2018-1-13 11:39:32 [InstanceLoader] ApplicationModule dependencies initialized +7ms
[Nest] 31827 - 2018-1-13 11:39:32 [RoutesResolver] AppController {/}: +34ms
[Nest] 31827 - 2018-1-13 11:39:32 [RouterExplorer] Mapped {/, GET} route +2ms
[Nest] 31827 - 2018-1-13 11:39:32 [NestApplication] Nest application successfully started +1ms

Install HTTP client

$ npm i --save axios

Build the first Service

import { Component } from '@nestjs/common';
import axios, { AxiosInstance } from 'axios';

@Component()
export class WeatherService {
    private client: AxiosInstance;

    constructor() {
        this.client = axios.create({
            baseURL: 'https://api.openweathermap.org/data/2.5/',
            params: {
                APPID: 'CHANGE_ME'
            }
          });
    }

    async ofCity(city: string): object {
        const response = await this.client.get('weather', {
            params: { q: city }
        });
        return response.data;
    }
}

HTTP communication layer

import { Get, Controller } from '@nestjs/common';
import { WeatherService } from './weather.service';

@Controller('weather')
export class WeatherController {
    constructor(private readonly weatherService: WeatherService) {}

	@Get()
	async root(): Promise< object > {
        const response = await this.weatherService.forCity('New York');
        return response;
  }
}

Connect the dots

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { WeatherController } from './weather.controller';
import { WeatherService } from './weather.service';

@Module({
  imports: [],
  controllers: [AppController, WeatherController],
  components: [WeatherService],
})
export class ApplicationModule {}

• Interfaces for return types. We can take a full advantage of using TypeScript and strongly type all the things
• Error handling. When the promise won’t resolve, our controller will very likely break
• Test suite. We haven’t written any tests yet
• We’re returning the whole data blob. We can strip out only the values we care about