API with NestJS #68. Interacting with the application through REPL

July 18, 2022

This entry is part 68 of 121 in the API with NestJS

The NestJS team officially announced NestJS 9 on July 8th. One of its features is Read-Eval-Print-Loop (REPL) implementation. It is an environment that allows us to interact with our NestJS application through the terminal.

In this article, we go through how to set up REPL with NestJS. We also use features built into NodeJS to make the most out of REPL in a way that the official NestJS documentation does not show currently.

Source: trilon.io

Setting up REPL

For REPL to work, we should create a repl.ts file in the same directory as main.ts.

repl.ts

import { repl } from '@nestjs/core';

import { AppModule } from './app.module';

async function bootstrap() {

await repl(AppModule);

}

bootstrap();

Let’s add a new script to our package.json file to run it.

package.json

"scripts": {

"start": "nest start",

"start:repl": "nest start --entryFile repl"

}

To start using REPL, we need to run npm run start:repl.Functions built into NestJS REPL

NestJS gives us a set of functions we can use to interact with our application.

To list all of built-in features, we can call the help() function.

method

We can use the methods utility if we want to list the public methods of a particular injectable or controller.

get

With the get function, we can get an instance of an injectable. A good example is getting a service and calling its method.

1	await get(UsersService).getByEmail('wanago.marcin@gmail.com')

In REPL, the await keyword is supported at the top level.

{

id: 1,

email: 'wanago.marcin@gmail.com',

name: 'Marcin',

isEmailConfirmed: true,

// ...

}

The crucial thing to realize is that when we use NestJS REPL, we run an instance of Node.js. It means that we can declare variables, for example.

1	const user = await get(UsersService).getByEmail('wanago.marcin@gmail.com');

1	await get(PostsService).createPost({ title: 'Lorem ipsum', paragraphs: ['Dolor sit amet'] }, user);

Unfortunately, we can’t type multiple lines before clicking enter, so we must input each line separately. To deal with the above issue, we can type .editor and click enter to go into the editor mode.

Instead of get(UsersService) we can also call $(UsersService) with the same result.

Trying to define the user variable more than once results in an error.

Uncaught SyntaxError: Identifier ‘user’ has already been declared

The .clear utility built into REPL resets the whole context and the declared variables. Unfortunately, this also gets rid of the features provided by NestJS, so we should abstain from using the .clear utility.

debug

With the debug functionality, we can see all registered modules with their controllers and providers.

By typing debug.help and clicking enter, we can see the documentation of the debug feature.

Print all registered modules as a list together with their controllers and providers.
If the argument is passed in, for example, “debug(MyModule)” then it will only print components of this specific module.
Interface: debug(moduleCls?: ClassRef | string) => void

In the documentation, we can see that we can pass a particular module to print only its components.

select

Allows us to pull out a specific instance from a selected module and navigate the modules tree. It uses the select method of the NestApplicationContext class that you can find in the repository.

1	select(UsersModule).get(UsersService)

resolve

The resolve functionality resolves transient and request-scoped providers. It works the same as the moduleRef.resolve method described in the documentation.

In our application, we have the PostsLoaders class. Since we marked it as request-scoped, we need to use resolve instead of the get function to refer to it.

1	resolve(PostsLoaders)

Using the underscore variable

To simplify how we use REPL, we can take advantage of the _ variable. It contains the result of the previously evaluated expression.

1	await get(UsersService).getByEmail('wanago.marcin@gmail.com');

1	_.email; // wanago.marcin@gmail.com

If we explicitly assign a value to the _ variable, the disable the above behaviour.

Besides _, we can also use _error to access the last error.

1	await get(UsersService).getByEmail('unknown@email.com');

1	_error.message // User with this email does not exist

Adding custom functions to the context

If we press the tab button twice, we see the full context of our REPL session.

We can see that NestJS loads our injectables into the context, such as the ConfigService or UsersService. Besides that, it also injects the features such as get, and debug. Fortunately, we have access to the context in the repl.ts file.

We can take advantage of the above and define the functions we often use.

repl.ts

import { repl } from '@nestjs/core';

import { AppModule } from './app.module';

import { UsersService } from './users/users.service';

import CreatePostDto from './posts/dto/createPost.dto';

import User from './users/user.entity';

import PostsService from './posts/posts.service';

async function bootstrap() {

const replServer = await repl(AppModule);

replServer.context.getUserByEmail = (userEmail: string) => {

const usersService: UsersService = replServer.context.get(UsersService);

return usersService.getByEmail(userEmail);

};

replServer.context.createPost = (post: CreatePostDto, user: User) => {

const postsService: PostsService = replServer.context.get(PostsService);

return postsService.createPost(post, user);

}

bootstrap();

The replServer variable is an instance of the REPLServer class.

Thanks to the fact that we’ve added the getUserByEmail function to the context, we can now use it directly with our NestJS REPL.

1	await getUserByEmail('wanago.marcin@gmail.com')

{

id: 1,

email: 'wanago.marcin@gmail.com',

name: 'Marcin',

isEmailConfirmed: true,

// ...

}

Saving and loading REPL sessions

Let’s say we’ve been playing with REPL for quite some time. We might decide that we want to store all of the commands we’ve run so far. We can achieve that with the .save command.

Doing the above stores all of the commands we’ve run to the specified file.

replSession.js

const user = await getUserByEmail('wanago.marcin@gmail.com');

const post = await createPost(

{

title: 'Lorem ipsum',

paragraphs: ['Dolor sit amet']

user

);

Thanks to saving the current session, we can use the .load command to run all of the commands specified in the file.

Summary

In this article, we’ve gone through the recent REPL feature that NestJS introduced. We’ve learned how to use it to interact with our application, for example, by calling various methods on our services. For example, it comes in handy when testing specific parts of our application. We’ve also gone through various features of REPL built into Node.js and learned how to utilize them to increase the developer experience. For example, we’ve managed to write multi-line scripts and attach custom functions to the NestJS REPL sessions. All of the above can be useful and make our life way easier.

Series Navigation<< API with NestJS #67. Migrating to TypeORM 0.3API with NestJS #69. Database migrations with TypeORM >>