DEV Community: Smrity Das

Nest.js GraphQL - The Code First Approach

Smrity Das — Fri, 09 Jun 2023 07:47:23 +0000

Introduction

REST has been the industry standard for creating web APIs in recent years. It offers a set of guidelines that can produce completely functional web services, but Rest's rules and restrictions become problematic. GraphQL enters software development to address Rest's issues.

API development is made simpler and more widely available by GraphQL. The purpose of this article is to introduce you to GraphQL and show you how to integrate the GraphQL client with React.

What is GraphQL?

GraphQL is a query language for APIs. It gives clients the power to ask for exactly what they need and nothing more, makes it easier to evolve APIs over time, and enables powerful developer tools. Being able to request the precise or exact data format that the client requires makes it more versatile than REST APIs.

Why NestJS?

NestJS is a framework for building efficient, scalable Node.js server-side applications. It uses progressive JavaScript, is built with and fully supports TypeScript (yet still enables developers to code in pure JavaScript) and combines elements of OOP (Object Oriented Programming), FP (Functional Programming), and FRP (Functional Reactive Programming). GraphQL and NestJS
combined with TypeScript helps you develop better type safety with your GraphQL queries, giving you end-to-end typing.

Code First

Instead of generating our GraphQL schema by manually writing GraphQL SDL, we use the code first methodology. Instead, we create the SDL from TypeScript class definitions using TypeScript decorators. The @nestjs/graphql package automatically creates the schema for you by reading the metadata specified by the decorators.

Nest.js GraphQL - The Code First Approach

Installation

First create a new project using Nest CLI and cd into that folder.

nest new your_project_name

Now let’s install the GraphQL dependencies.

npm i @nestjs/graphql @nestjs/apollo graphql apollo-server-express

Let’s install other dependencies we’ll be needing.

npm i class-transformer class-validator @prisma/client bson-objectid npm i -D prisma

Configure GraphQL Module

Once the required packages have been installed, we can import the GraphQLModule and set its forRoot() static method configuration.

Nest.js GraphQL - The Code First Approach

The forRoot() takes an options object as an argument. These options are passed through to the underlying driver instance. Here we’re using Apollo as our driver.

Initialize Prisma Schema

Since we’ll be using prisma let’s generate the schema for it. To generate a prisma schema run the following command

npx prisma generate

This command will create a prisma folder and a schema.prisma file inside it. Let’s modify it add the following code.

This Coffees model will represent out collection in the database. You can add more fields if you want to.

That prisma command will also generate a .env file where you can put your database URL. I’ll be using MongoDB Atlas for this project. So create a database and add that to your .env file. Don’t forget to add it to your .gitignore file.

Prisma Module

Let’s generate the prisma module and service we’ll be using throughout the app for database interactions.

nest g mo prisma nest g service prisma --no-spec

These command will create a prisma folder inside src and add two files prisma.module.ts and prisma.service.ts Open the prisma.service.ts file and the following code.

Coffee Module

We’ll be building an imaginary coffee GraphQL api. Let’s generate the module, resolver and service for coffees.

nest g mo coffee nest g resolver coffee --no-spec nest g service coffee --no-spec

Before continuing let’s add the following code in your nest-cli.json file. This will help us to remove a lot of redundant typing.

"compilerOptions": { "plugins": ["@nestjs/graphql"]

Coffee Model

Coffee model will represent the coffee collection and ObjectType which is required if you want to use that as response type. Create a model folder inside coffee folder and coffee.model.ts and add the following code.

Most of the definitions in a GraphQL schema are object types. Each object type you define should represent a domain object that an application client might need to interact with. Coffee will be the response type that’s why we’ve use the ObjectType decorator.

Generating Input Types

If the mutation or query needs to take an object as an argument, we can create an input type. The input type is a special kind of object type that can be passed in as an argument. To declare an input type, use the @InputType() decorator. We’ll need 3 input types for creating coffee, updating coffee and pagination. So, create a folder tscoffee/dto and add 3 files, create-coffee.dto.ts , update-coffee.dto.ts and pagination.dto.ts and add the following code.
create-coffee.dto.ts

update-coffee.dto.ts

pagination.dto.ts

Providers

An essential idea in Nest is the concept of providers. The core Nest classes, such as services, repositories, factories, helpers, and so forth, can be be thought of as providers. The fundamental benefit of a provider is that it may be injected as a dependency.

As a result, objects can establish a variety of connections with one another, and the Nest runtime system can take on a considerable portion of the work of "wiring up" instances of objects.

Our coffee.service.ts file will act as abstract layer for interacting with the coffees collection. Open it and add the following code.

This is our typical CRUD operations logic. Here I’m using the PrismaErrorCodes enum to store the conflict error code.
prisma-error-codes.enum.ts

Resolvers

Resolvers offer the guidelines for converting a GraphQL operation (a query, mutation, or subscription) into data. They deliver the exact data shape that we specify in our schema, either synchronously or as a promise that resolves to that shape's result. A resolver map is often made by hand. On the other hand, the @nestjs/graphql package automatically creates a resolver map using the metadata supplied by the decorators you use to annotate classes.

At this point, we've defined the objects (type definitions) that can exist in our data graph, but clients don't yet have a way to interact with those objects. To address that, we need to create a resolver class. Resolver decorator exported from @nestjs/graphql package marks a class as a resolver. To query something we need to use the Query decorator exported from @nestjs/graphql. For example -

Here I’m using @Query() decorator to mark findAll method as a query type. I’m returning an array of coffees to indicate that when this query is resolved it will return an array of coffee. By default the query will be named as same as the method name that is findAll. Using the name property will override it. If you need any arguments to your query or mutation use can use the @Args() decorator.

For normal types like string or number NestJS GraphQL package will automatically infer them. But sometimes our input types are complicated which can’t be inferred. In that case we can use the type property to provide metadata. You mutate we use the
@Mutation() decorator.

Now that you understand all the decorators open the coffee.resolver.ts file that we generated a while ago and add the following code.

Subscriptions

The GraphQL specification includes a third operation type called subscription in addition to query-based data retrieval and mutation-based data modification. Data can be pushed from the server to clients who opt to receive real-time messages from the server via GraphQL subscriptions. Similar to queries in that they describe a collection of fields to be supplied to the client, subscriptions establish a channel and send a result to the client each time a specific event occurs on the server rather than returning a single answer right away.

To add subscriptions to our API we need to add the subscriptions property in app.module.ts. Let’s modify the app.module.ts and replace with the following code.

We utilize the @Subscription() decorator (exported from the @nestjs/graphql package) and the PubSub class from the graphql-subscriptions package, which provides a straightforward publish/subscribe API, to construct a subscription using the code first methodology.
npm i graphql-subscriptions

Add the following code to coffee/constants/subscriptions.ts

We’ll add subscriptions to createCoffee . So each time we create a new coffee we’ll get the real time updates.

Import the PubSub constructor from graphql-subscriptions and create an instance.

Now open coffee.resolver.ts file and add the following code.

Remember to import the @Subscription decorator from @nestjs/graphql and the COFFEE_ADDED constants.

Now replace the createCoffee mutation code with the following.

Generated Schema

Query Examples

Read an article on Care Insider

Nodejs Async Hooks 101

Smrity Das — Fri, 19 May 2023 07:54:06 +0000

Node.js is a highly scalable and performance-oriented platform that enables developers to create applications that are fast, efficient, and lightweight. One of Node.js' key features is its ability to handle multiple asynchronous operations at the same time using a single-threaded event loop.

Async Hooks is a new Node.js feature that allows developers to access the event loop and track the lifecycle of asynchronous operations in their applications. This feature provides information about how asynchronous operations are carried out and can aid in the identification of potential performance issues and bottlenecks.

Developers can use Async Hooks to get information about the current state of an asynchronous operation and receive notifications when it begins, ends, or encounters an error. This data can be used to determine how long an asynchronous operation takes, what resources it consumes, and how it affects the application's overall performance.

Async Hooks are implemented as Node.js callbacks registered with the async_hooks module. Callbacks are informed about the current asynchronous operation and can be used to record data, track resources, and manage performance.

Async Hooks can be used to provide custom logic for monitoring and managing asynchronous actions in addition to offering performance insights. Async Hooks can be used by developers, for instance, to provide unique resource management, error handling, and logging solutions.

Async Hooks, a potent new feature of Node.js that gives developers more insight into the inner workings of asynchronous actions, is summarised above. With this knowledge, programmers may create apps that are quicker and more effective, and they can also rapidly locate and fix performance problems.

Example of aync_hook implementation:

In this example, we define a set of hooks for tracking asynchronous operations. The hooks include init , before , after , destroy , and promiseResolve .

We then create an Async Hook using async_hooks.createHook and pass in the hooks. The created hook is then enabled using asyncHook.enable() .

We also have a setTimeout function that will execute after 1000 milliseconds, which will trigger the hooks to be called.

Finally, when the Node.js process is about to exit, the hook is disabled using asyncHook.disable() .

When you run this code, you will see output from the hooks that log information about the asynchronous operation triggered by the setTimeout function.

const async_hooks = require('async_hooks');
const hooks = {
init: (asyncId, type, triggerAsyncId, resource) => {
console.log(`Init Hook: asyncId: ${asyncId}, type: ${type}`);
},
before: (asyncId) => {
console.log(`Before Hook: asyncId: ${asyncId}`);
},
after: (asyncId) => {
console.log(`After Hook: asyncId: ${asyncId}`);
},
destroy: (asyncId) => {
console.log(`Destroy Hook: asyncId: ${asyncId}`);
},
promiseResolve: (asyncId) => {
console.log(`Promise Resolve Hook: asyncId: ${asyncId}`);
},
};

const asyncHook = async_hooks.createHook(hooks);
asyncHook.enable();
setTimeout(() => {
console.log('Timeout finished');
}, 1000);
process.on('exit', () => {
asyncHook.disable();
});

Async Hooks should be used in the following scenarios:

Performance Monitoring: Async Hooks offers information on the manner in which asynchronous operations are carried out, how long they take to complete, and what resources they use. This data can be used to track your application's performance and spot any potential performance bottlenecks.
Resource management: Resources connected to asynchronous operations can be managed and tracked using async hooks. Async Hooks can be used, for instance, to track and release file descriptors, network connections, and other resources that
asynchronous actions acquire and use.
Error Handling: Custom error handling for asynchronous activities can be implemented using async hooks. Instead of handling errors in each individual asynchronous action, you may utilize Async Hooks to find errors and handle them centrally.
Logging: Async Hooks can be used to log information about asynchronous operations and their lifecycle. This information can be used for debugging and troubleshooting, as well as for performance analysis and optimization.

Async Hook Resource Management Example:

const async_hooks = require('async_hooks');
const fs = require('fs');
const activeResources = new Map();
const hooks = {
init: (asyncId, type, triggerAsyncId, resource) => {
if (type === 'FSREQWRAP') {
activeResources.set(asyncId, resource);
}
},
before: (asyncId) => {},
after: (asyncId) => {},
destroy: (asyncId) => {
const resource = activeResources.get(asyncId);
if (resource) {
resource.close();
activeResources.delete(asyncId);
}
},
promiseResolve: (asyncId) => {},
};

const asyncHook = async_hooks.createHook(hooks);
asyncHook.enable();
fs.open('test.txt', 'r', (err, fd) => {
if (err) {
console.error(err);
return;
}
console.log(`Opened file descriptor: ${fd}`);
});
process.on('exit', () => {
asyncHook.disable();
});

Read an article on EHR Integration

techvariable.com