DEV Community: Dylan 💻

Building A RESTful CRUD API with Nest.js, TypeORM & PostgreSQL: A Step-by-Step Guide

Dylan 💻 — Wed, 20 Dec 2023 23:02:05 +0000

Embark on a personal exploration of building a robust REST API with Nest.js, TypeORM, and PostgreSQL. Throughout this series, I'll guide you through the essentials, from setting up a Nest.js project to connecting to PostgreSQL and implementing RESTful endpoints. We'll delve into the intricacies of database operations, whether you're an experienced developer or just starting, join me on this journey to master the powerful combination of Nest.js, TypeORM, and PostgreSQL, enhancing your backend development skills along the way!

RESTful API Standards

Routes	Description
GET /api/v1/goals	Get goals
GET /api/v1/goals/1	Get goal with id of 1
POST /api/v1/goals	Add a goal
PUT /api/v1/goals/1	Update goal with id of 1
PATCH /api/v1/goals/1	Partially Update goal with id of 1
DELETE /api/v1/goals/1	Delete goal with id of 1

Setting Up Your Development Environment

Before we start building our API, we first scaffold the project with the Nest CLI.

Install Nest.js globally:
```
npm i -g @nestjs/cli
```
Scaffold the project:
```
nest new goal-tracker-nestjs
```
Navigate to your directory that you just created with the following:
```
cd goal-tracker-nestjs
```
Start the server
```
npm run start:dev
```

Setting A Global Prefix For Our API

Before we jump into creating our API, lets quickly add a prefix to it.

Open main.ts in /src and add the following:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.setGlobalPrefix('api/v1'); // Adds prefix
  await app.listen(3000);
}
bootstrap();

Creating Our Controllers

Controllers are responsible for handling incoming requests and returning responses to the client.

Let's create our controllers. To create a new controller type the following command:
```
nest generate controller goals
```

Now we need to update our goals.controller.ts file to the following:

import { Controller, Delete, Get, Patch, Post } from '@nestjs/common';

@Controller('goals')
export class GoalsController {
    @Get()
    findAll() {}

    @Get()
    findOne() {}

    @Post()
    create() {}

    @Patch()
    update() {}

    @Delete()
    remove() {}
}

Now we need to register this controller with Nest.js. Add GoalsController to the controllers array.

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { GoalsController } from './goals/goals.controller';

@Module({
  imports: [],
  controllers: [AppController, GoalsController],
  providers: [AppService],
})
export class AppModule {}

You are done, you will now get successful responses back from the API if you send a GET, POST, PATCH or DELETE to http://localhost:3000/api/v1/goals.

Adding Route Parameters To Our Controllers

We would want to add Route Parameters if we want to have dynamic routes and to extract values from the URL.

Update our goals.controller.ts file to the following:

import { Controller, Delete, Get, Param, Patch, Post } from '@nestjs/common';

@Controller('goals')
export class GoalsController {
  @Get()
  findAll() {}

  // Example #1 - Value
  @Get(':id')
  findOne(@Param('id') id) {
    return id; 
    // 1
  }

  // Example #2 - JSON Object
  @Get(':id')
  findOne(@Param() id) {
    return id;
    // {
    //    "id": "1"
    // }
  }

  @Post()
  create() {}

  @Patch(':id')
  update(@Param('id') id) {}

  @Delete(':id')
  remove(@Param('id') id) {}
}

Adding The Request Body

We need to create our Goal Model/Schema in order to describe how our data is going to look like, there are also some other use cases such as data validation, security, etc.

Update our goals.controller.ts file to the following:

import {
  Body,
  Controller,
  Delete,
  Get,
  Param,
  Patch,
  Post,
} from '@nestjs/common';

@Controller('goals')
export class GoalsController {
  // ...

  @Post()
  create(@Body() input) {
    return input;
  }

  @Patch(':id')
  update(@Param('id') id, @Body() input) {}

  // ...
}

Adding The Responses & Status Codes

By default Nest.js adds the HTTP Codes for you but if you want to give a specific Controller a HTTP Code you can do so with the decorator @HttpCode(204). We are going to update the current API with the following:

Update our goals.controller.ts file to the following:

import {
  Body,
  Controller,
  Delete,
  Get,
  HttpCode,
  Param,
  Patch,
  Post,
} from '@nestjs/common';

@Controller('goals')
export class GoalsController {
  @Get()
  findAll() {
    return [
      { id: 1, name: 'Goal 1' },
      { id: 2, name: 'Goal 2' },
      { id: 3, name: 'Goal 3' },
    ];
  }

  @Get(':id')
  findOne(@Param('id') id) {
    return {
      id: 1,
      name: 'Goal 1',
    };
  }

  @Post()
  create(@Body() input) {
    return input;
  }

  @Patch(':id')
  update(@Param('id') id, @Body() input) {
    return input;
  }

  @Delete(':id')
  @HttpCode(204)
  remove(@Param('id') id) {}
}

Creating Our Data Transfer Objects (DTO)

We use Data Transfer Objects (DTO) for defining the input properties and their types upfront.

Request Payload (Create)

Let's create our Create DTO. Create a new file called create-goal.dto.ts in the directory /src/goals/dtos

Now we need to update our create-goal.dto.ts file to the following:

export class CreateGoalDto {
  name: string;
  priority: string;
  status: string;
  createdAt: string;
  updatedAt: string;
}

Now we need to update our goals.controller.ts file to the following:

import {
  Body,
  Controller,
  Delete,
  Get,
  HttpCode,
  Param,
  Patch,
  Post,
} from '@nestjs/common';
import { CreateGoalDto } from './dtos/create-goal.dto';

@Controller('goals')
export class GoalsController {
  // ...

  @Post()
  create(@Body() input: CreateGoalDto) {
    return input;
  }

  // ...
}

Update Payload (Update)

Install @nestjs/mapped-types:
```
npm i @nestjs/mapped-types
```
Let's create our Update DTO. Create a new file called update-goal.dto.ts in the directory /src/goals/dtos

Now we need to update our update-goal.dto.ts file to the following:

import { PartialType } from '@nestjs/mapped-types';
import { CreateGoalDto } from './create-goal.dto';

// Pulls types from CreateGoalDto into UpdateGoalDto
export class UpdateGoalDto extends PartialType(CreateGoalDto) {}

To make our code a bit more cleaner, lets combine the Classes together into a single file with the following:

// index.ts
import { CreateGoalDto } from './create-goal.dto';
import { UpdateGoalDto } from './update-goal.dto';

export { CreateGoalDto, UpdateGoalDto };

Now we need to update our goals.controller.ts file to the following:

import {
  Body,
  Controller,
  Delete,
  Get,
  HttpCode,
  Param,
  Patch,
  Post,
} from '@nestjs/common';
import { CreateGoalDto, UpdateGoalDto } from './dtos/index';

@Controller('goals')
export class GoalsController {
  // ...

  @Patch(':id')
  update(@Param('id') id, @Body() input: UpdateGoalDto) {
    return input;
  }

  // ...
}

Example of Our API Working In A Session (Without Being Connected To A Database)

Before we create our entity let's create Enums for our priority and status type. Create a new file called priority.enum.ts and another called status.enum.ts in the directory /src/goals/enums

Now we need to update our priority.enum.ts to the following:

// priority.enum.ts
export enum Priority {
  LOW = 'Low',
  MEDIUM = 'Medium',
  HIGH = 'High',
}

Now we need to update our status.enum.ts to the following:

// status.enum.ts
export enum Status {
  PENDING = 'Pending',
  IN_PROGRESS = 'In Progress',
  COMPLETED = 'Completed',
}

To make our code a bit more cleaner, lets combine the Enums together into a single file with the following:

// index.ts
import { Priority } from './priority.enum';
import { Status } from './status.enum';

export { Priority, Status };

Now we need to update our create-goal.dto.ts file to the following:

import { Priority, Status } from '../enums';

export class CreateGoalDto {
  name: string;
  priority: Priority;
  status: Status;
  createdAt: string;
  updatedAt: string;
}

Let's create our Entity. Create a new file called goal.entity.ts in the directory /src/goals/entities

Now we need to update our goal.entity.ts file to the following:

import { Priority, Status } from '../enums';

export class Goal {
  id: number;
  name: string;
  priority: Priority;
  status: Status;
  createdAt: Date;
  updatedAt: Date;
}

Now we need to update our goals.controller.ts file to the following:

import {
  Body,
  Controller,
  Delete,
  Get,
  HttpCode,
  Param,
  Patch,
  Post,
} from '@nestjs/common';
import { CreateGoalDto, UpdateGoalDto } from './dtos/index';
import { Goal } from './entities/goal.entity';
import { Priority, Status } from './enums/index';

@Controller('goals')
export class GoalsController {
  private goals: Goal[] = [
    {
      id: 1,
      name: 'Learn tRPC',
      priority: Priority.LOW,
      status: Status.PENDING,
      createdAt: new Date(),
      updatedAt: new Date(),
    },
    {
      id: 2,
      name: 'Learn Nest.js',
      priority: Priority.HIGH,
      status: Status.IN_PROGRESS,
      createdAt: new Date(),
      updatedAt: new Date(),
    },
  ];

  // GET /api/v1/goals
  @Get()
  findAll() {
    return this.goals;
  }

  // GET /api/v1/goals/:id
  @Get(':id')
  findOne(@Param('id') id) {
    const goal = this.goals.find((goal) => goal.id === parseInt(id));

    return goal;
  }

  // POST /api/v1/goals
  @Post()
  create(@Body() input: CreateGoalDto) {
    const goal = {
      ...input,
      createdAt: new Date(input.createdAt),
      updatedAt: new Date(input.updatedAt),
      id: this.goals.length + 1,
    };

    this.goals.push(goal);
  }

  // PATCH /api/v1/goals/:id
  @Patch(':id')
  update(@Param('id') id, @Body() input: UpdateGoalDto) {
    const index = this.goals.findIndex((goal) => goal.id === parseInt(id));

    this.goals[index] = {
      ...this.goals[index],
      ...input,
      createdAt: input.createdAt
        ? new Date(input.createdAt)
        : this.goals[index].createdAt,
      updatedAt: input.updatedAt
        ? new Date(input.updatedAt)
        : this.goals[index].updatedAt,
    };

    return this.goals[index];
  }

  // DELETE /api/v1/goals/:id
  @Delete(':id')
  @HttpCode(204)
  remove(@Param('id') id) {
    this.goals = this.goals.filter((goal) => goal.id !== parseInt(id));
  }
}

You can make the following requests to each endpoint and the responses will be cached in each session to simulate a real working API.

Setting Up & Connecting To Our Database

Installing TypeORM & PostgreSQL

Install TypeORM and the database you want to use, in this case we will use PostgreSQL (pg):
```
npm install @nestjs/typeorm typeorm pg
```

Creating Our Database

Open your favourite database management tool, in this case I will be using pgAdmin.
Right-Click Databases > Create > Database...
Name you database whatever you like, we will be using goaltracker-db
Now, Click Save

Connecting To Our Database

Let's create two database configurations, one for production called orm.config.prod.ts and the other for development called orm.config.ts in the directory /src/config

Now we need to update orm.config.prod.ts to the following:

// orm.config.prod.ts
import { registerAs } from '@nestjs/config';
import { TypeOrmModuleOptions } from '@nestjs/typeorm';
import { Goal } from 'src/goals/entities/goal.entity';

export default registerAs(
  'orm.config',
  (): TypeOrmModuleOptions => ({
    type: 'postgres',
    host: '<YOUR_HOST>',
    port: 5432,
    username: '<YOUR_PRODUCTION_DATABASE_USERNAME>',
    password: '<YOUR_PRODUCTION_DATABASE_PASSWORD>',
    database: 'goaltracker-db',
    entities: [Goal],
    synchronize: false, // Disable this always in production
  }),
);

Now we need to update orm.config.ts to the following:

// orm.config.ts
import { registerAs } from '@nestjs/config';
import { TypeOrmModuleOptions } from '@nestjs/typeorm';
import { Goal } from 'src/goals/entities/goal.entity';

export default registerAs(
  'orm.config',
  (): TypeOrmModuleOptions => ({
    type: 'postgres',
    host: 'localhost',
    port: 5432,
    username: 'postgres',
    password: '<YOUR_DATABASE_PASSWORD>',
    database: 'goaltracker-db',
    entities: [Goal],
    synchronize: true,
  }),
);

Install @nestjs/config since we will be needing it next:
```
npm install @nestjs/config
```

Now, in our app.module.ts we need to update our file to the following to use our configuration:

// app.module.ts
import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import ormConfig from './config/orm.config';
import ormConfigProd from './config/orm.config.prod';
import { Goal } from './goals/entities/goal.entity';
import { GoalsController } from './goals/goals.controller';

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
      load: [ormConfig],
      expandVariables: true,
    }),
    TypeOrmModule.forRootAsync({
      useFactory:
        process.env.NODE_ENV !== 'production' ? ormConfig : ormConfigProd,
    }),
    TypeOrmModule.forFeature([Goal]),
  ],
  controllers: [AppController, GoalsController],
  providers: [AppService],
})
export class AppModule {}

Finally, we will need to mark our Goal Class as an Entity and the properties as Columns so that we can define the structure of our data. Update goal.entity.ts to the following:

// goal.entity.ts
import {
  Column,
  CreateDateColumn,
  Entity,
  PrimaryGeneratedColumn,
  UpdateDateColumn,
} from 'typeorm';
import { Priority, Status } from '../enums';

@Entity()
export class Goal {
  @PrimaryGeneratedColumn('uuid')
  id: number;

  @Column()
  name: string;

  @Column({
    type: 'enum',
    enum: Priority,
    default: Priority.LOW,
  })
  priority: Priority;

  @Column({
    type: 'enum',
    enum: Status,
    default: Status.PENDING,
  })
  status: Status;

  @CreateDateColumn()
  createdAt: Date;

  @UpdateDateColumn()
  updatedAt: Date;
}

Restart the server and you should see your table appear in your database with all of the columns.

Example of Our API Working (While Connected To A Database)

Update our goals.controller.ts file to the following:

import {
  Body,
  Controller,
  Delete,
  Get,
  HttpCode,
  NotFoundException,
  Param,
  Patch,
  Post,
} from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { CreateGoalDto, UpdateGoalDto } from './dtos/index';
import { Goal } from './entities/goal.entity';

@Controller('goals')
export class GoalsController {
  // Dependency Injection
  constructor(
    @InjectRepository(Goal) private readonly repository: Repository<Goal>,
  ) {}

  // GET /api/v1/goals
  @Get()
  async findAll() {
    const goals = await this.repository.find();

    return { success: true, count: goals.length, data: goals };
  }

  // GET /api/v1/goals/:id
  @Get(':id')
  async findOne(@Param('id') id) {
    const goal = await this.repository.findOneBy({ id });

    if (!goal) {
      throw new NotFoundException();
    }

    return { success: true, data: goal };
  }

  // POST /api/v1/goals
  @Post()
  async create(@Body() input: CreateGoalDto) {
    const goal = await this.repository.save({
      ...input,
      createdAt: input.createdAt,
      updatedAt: input.updatedAt,
    });

    return { success: true, data: goal };
  }

  // PATCH /api/v1/goals/:id
  @Patch(':id')
  async update(@Param('id') id, @Body() input: UpdateGoalDto) {
    const goal = await this.repository.findOneBy({ id });

    if (!goal) {
      throw new NotFoundException();
    }

    const data = await this.repository.save({
      ...goal,
      ...input,
      createdAt: input.createdAt ?? goal.createdAt,
      updatedAt: input.updatedAt ?? goal.updatedAt,
    });

    return { success: true, data };
  }

  // DELETE /api/v1/goals/:id
  @Delete(':id')
  @HttpCode(204)
  async remove(@Param('id') id) {
    const goal = await this.repository.findOneBy({ id });

    if (!goal) {
      throw new NotFoundException();
    }

    await this.repository.remove(goal);
  }
}

You can make the following requests to each endpoint and your database will populate with data.

In summary, the use of Nest.js, TypeORM, and PostgreSQL facilitates the creation of a robust and scalable REST API. Nest.js provides a modular structure, TypeORM streamlines database interactions, and PostgreSQL ensures efficiency. This powerful combination enables developers to build high-performance APIs that adhere to best practices, fostering reliable and maintainable backend systems.

Code

If you want to refer to the code you can do so here.

Thanks for reading!

Have a question? Connect with me via Twitter or send me a message at hello@dylansleith.com

Building & Consuming A RESTful CRUD API with Next.js, Tailwind, Node.js & Express: A Step-by-Step Guide (Part 1)

Dylan 💻 — Mon, 30 Oct 2023 17:57:29 +0000

In the constantly changing realm of web development, creating robust APIs is essential for seamless communication between applications. Representational State Transfer (REST) APIs, known for their simplicity and adaptability, have emerged as a universal preference among developers globally. In this guide, we will go through the process of building and consuming a RESTful CRUD API using the popular Node.js runtime environment and the Express.js framework by building a Goal Tracker.

Understanding CRUD

Before we get started, let's understand what a RESTful CRUD API is. CRUD stands for Create, Read, Update, and Delete. It's an acronym used in computer programming to describe the four basic functions of a persistent storage system, like a database. These operations allow users to interact with data by creating new records, reading existing records, updating existing records, and deleting records that are no longer needed.

CRUD operations are fundamental in web development because they enable applications to interact with and manage data effectively, providing a seamless experience for users.

RESTful API Standards

Routes	Description
GET /goals	Get goals
GET /goals/1	Get goal with id of 1
POST /goals	Add a goal
PUT /goals/1	Update goal with id of 1
DELETE /goals/1	Delete goal with id of 1

Setting Up Your Development Environment

Before we start building our API, we first need to set up our development environment.

Create a new directory:
```
mkdir goal-tracker
```
Navigate to your directory that you just created with the following:
```
cd goal-tracker
```
Initialize your Node.js project:
```
npm init -y
```

Setting Up Our Server

Installing Express & Environment Variables

Install express & dotenv
```
npm install express dotenv
```

Installing Nodemon

Nodemon is used to automatically restart the node application when a file changes.

Install nodemon
```
npm install -D nodemon
```

Installing Colors

Install colors (Optional - This just allows us to be able to distinguish between different messages within our console)
```
npm install colors
```
1. Import colors in server.js to be able to use it
```
import colors from 'colors';
```

Updating Our Scripts

Update your scripts in the package.json to include the following:

{
  "name": "goal-tracker",
  "version": "1.0.0",
  "description": "A goal tracking application to keep track of your goals",
  "main": "server.js",
  "scripts": {
    "start": "SET NODE_ENV=production & node server",
    "dev": "nodemon server"
  },
  "keywords": [],
  "author": "Dylan Sleith",
  "license": "ISC",
}

Adding Our Environment Variables

Create a file on the root of your project called .env and add the following:
```
NODE_ENV=development
PORT=5000
```

Creating Our CRUD Routes

First let's allow us to be able to use ES Modules in Node.js by adding the following into our package.json
```
{
  // ...
  "type": "module"
}
```

Let's add a basic setup for our routes. As a boilerplate, we can use the following code to set up our server with different routes depending on our CRUD operations. We will be refactoring this later on!

import express from 'express';
import dotenv from 'dotenv';
import colors from 'colors';

// Load environment variables
dotenv.config();

// Initialize Express
const app = express();

// CRUD Routes
app.get('/api/v1/goals', (req, res) => {
    res.status(200).json({ success: true, msg: 'Show all goals'});
});

app.get('/api/v1/goals/:id', (req, res) => {
    res.status(200).json({ success: true, msg: `Get goal ${req.params.id}` });
});

app.post('/api/v1/goals', (req, res) => {
    res.status(200).json({ success: true, msg: 'Create new goal'});
});

app.put('/api/v1/goals/:id', (req, res) => {
    res.status(200).json({ success: true, msg: `Update goal ${req.params.id}` });
});

app.delete('/api/v1/goals/:id', (req, res) => {
    res.status(200).json({ success: true, msg: `Delete goal ${req.params.id}` });
});

// Port
const PORT = process.env.PORT || 5000;

// Listen for requests
app.listen(
  PORT,
  console.log(
    `Server is running in ${process.env.NODE_ENV} mode on port ${PORT}`.yellow
      .bold
  )
);

Now, let's separate our routes into its own folder so everything is not in the main server.js file. Create a new file in /routes called goals.js and move the routes from server.js to the new file, goals.js.

import express from 'express';
const router = express.Router();

// CRUD Routes
router.get('/', (req, res) => {
    res.status(200).json({ success: true, msg: 'Show all goals' });
});

router.get('/:id', (req, res) => {
    res.status(200).json({ success: true, msg: `Get goal ${req.params.id}` });
});

router.post('/', (req, res) => {
    res.status(200).json({ success: true, msg: 'Create new goal'});
});

router.put('/:id', (req, res) => {
    res.status(200).json({ success: true, msg: `Update goal ${req.params.id}`});
});

router.delete('/:id', (req, res) => {
    res.status(200).json({ success: true, msg: `Delete goal ${req.params.id}`});
});

export default router;

Now, update server.js with the following:

import express from 'express';
import dotenv from 'dotenv';
import colors from 'colors';
import goals from './routes/goals.js';

// Load environment variables
dotenv.config();

// Initialize Express
const app = express();

// Mount routers
app.use('/api/v1/goals', goals); // "/api/v1/goals" => "/"

// Port
const PORT = process.env.PORT || 5000;

// Listen for requests
app.listen(
  PORT,
  console.log(
    `Server is running in ${process.env.NODE_ENV} mode on port ${PORT}`.yellow
      .bold
  )
);

Creating Our Controllers

Controllers are responsible for handling incoming requests and returning responses to the client.

Let's create our controllers. Create a new file in /controllers called goals.js and add the following controllers:

// Goals CRUD Routes

// @desc Get all goals
// @route GET /api/v1/goals
// @access Public
export const getGoals = (req, res, next) => {
  res.status(200).json({ success: true, msg: 'Show all goals' });
};

// @desc Get single goal
// @route GET /api/v1/goals/:id
// @access Public
export const getGoal = (req, res, next) => {
  res.status(200).json({ success: true, msg: `Get goal ${req.params.id}` });
};

// @desc Create new goal
// @route POST /api/v1/goals
// @access Private
export const createGoal = (req, res, next) => {
  res.status(200).json({ success: true, msg: 'Create new goal' });
};

// @desc Update goal
// @route PUT /api/v1/goals/:id
// @access Private
export const updateGoal = (req, res, next) => {
  res.status(200).json({ success: true, msg: `Update goal ${req.params.id}` });
};

// @desc Delete goal
// @route DELETE /api/v1/goals/:id
// @access Private
export const deleteGoal = (req, res, next) => {
  res.status(200).json({ success: true, msg: `Delete goal ${req.params.id}` });
};

Now we need to update our routes.js file to the following:

import express from 'express';
const router = express.Router();

// Import Controllers
import {
  getGoals,
  getGoal,
  createGoal,
  updateGoal,
  deleteGoal,
} from '../controllers/goals.js';

// Attach Controllers to Routes
router.route('/').get(getGoals).post(createGoal);

router.route('/:id').get(getGoal).put(updateGoal).delete(deleteGoal);

// Export router
export default router;

Setting Up & Connecting To Our Database

Creating Your Project

Go to https://account.mongodb.com/account/login and log in
Click Projects > New Project
Enter your project name, in this case we will use GoalTracker, then click Next
Now click Create Project

Creating Your Project

Make sure you are on the Overview tab, then click Create
Use the following to setup your Cluster
1. Cluster: M0
2. Provider: AWS
3. Region: us-east-1
4. Name: (Your Cluster Name)
Now click Create

Creating A Database User

Make sure you are on the Database Access tab, then click Add New Database User
Use the following to create your Database User
1. Authentication Method: Password
2. Password Authentication:
  1. Username: (Your Username)
  2. Password: (Your Password)
3. Database User Privileges: Read and write to any database
Now click Add User

Whitelisting Our IP Address

Make sure you are on the Network Access tab, then click Add IP Address
Click Add Current IP Address and it will auto populate the field for you with your IP address or just click Allow Access From Anywhere to allow access from any IP address
Now click Confirm

Connecting To Our Database Using MongoDB Compass

Make sure you are on the Overview tab, then click Connect
Under Access your data through tools, click Compass
Copy the Connection String, then open MongoDB Compass
In MongoDB Compass, under New Connection, paste the Connection String that you just copied
```
mongodb+srv://username:<password>@goaltracker.ofvhjnl.mongodb.net/
```
Now click Connect

Connecting To Our Database Within Our Project

Install mongoose
```
npm install mongoose
```

Add a new environment variable to your .env file:

MONGO_URI=mongodb+srv://username:<password>@goaltracker.ofvhjnl.mongodb.net/goaltracker

Create a new directory called /lib and then create a new file in that directory called db.js and add the following:

import mongoose from 'mongoose';

const connectDb = async () => {
  const conn = await mongoose.connect(process.env.MONGO_URI, {
    useNewUrlParser: true,
    useUnifiedTopology: true,
  });

  console.log(`MongoDB Connected: ${conn.connection.host}`.cyan.underline.bold);
};

export default connectDb;

Now in server.js we need to connect to our MongoDB Database, add connectDb(); after you load your environment variables in server.js:

import express from 'express';
import dotenv from 'dotenv';
import colors from 'colors';
import goals from './routes/goals.js';
import connectDb from './lib/db.js';

// Load environment variables
dotenv.config();

// Connect to database
connectDb();

// Initialize Express
const app = express();

// ...

Creating Our Goal Model/Schema

We need to create our Goal Model/Schema in order to describe how are data is going to look like, there are also some other use cases such as data validation, security, etc.

Create a new directory called /model and then create a new file in that directory called Goal.js and add the following:

import mongoose from 'mongoose';

const GoalSchema = new mongoose.Schema({
  name: {
    type: String,
    required: [true, 'Please add a goal name'],
    unique: true,
    trim: true,
    maxLength: [20, 'Goal name can not be more than 20 characters'],
  },
  priority: {
    type: String,
    required: true,
    enum: ['Low', 'Medium', 'High'],
  },
  status: {
    type: String,
    required: true,
    enum: ['Pending', 'In Progress', 'Completed'],
  },
  createdAt: {
    type: Date,
    default: Date.now,
  },
  updatedAt: {
    type: Date,
    default: Date.now,
  },
});

export default mongoose.model('Goal', GoalSchema);

Creating Our CRUD Operations

POST (Create) - Create New Goal

Creating Our POST Request

Before we get started, we need to go into our server.js file and add the Body Parser middleware so that we can read data from the request.

import express from 'express';
import dotenv from 'dotenv';
import colors from 'colors';
import goals from './routes/goals.js';
import connectDb from './lib/db.js';

// ...

// Body parser
app.use(express.json());

We need to add the following logic into our createGoal controller to have a working endpoint for our POST request:

// @desc Create new goal
// @route POST /api/v1/goals
// @access Private
export const createGoal = async (req, res, next) => {
  try {
    const goal = await Goal.create(req.body);

    res.status(201).json({
      success: true,
      data: goal,
    });
  } catch (err) {
    res.status(400).json({
      success: false,
    });
  }
};

Testing Our POST Request in Postman

Open Postman
Create a new HTTP Request
Add the following information to the request
1. URL: http://localhost:5000/api/v1/goals
2. Method: POST
3. Headers: 'Content-Type': 'application/json'
4. Body (raw JSON):
```
{
    "name": "Learn tRPC",
    "priority": "Medium",
    "status": "Completed"
}
```
Click Send and you will get a response of 201 Created which means you have successfully created a new record and it will be created in your database.

GET (Read) - Get All Goals

Creating Our GET Request

We need to add the following logic into our getGoals controller to have a working endpoint for our GET request:

// @desc Get all goals
// @route GET /api/v1/goals
// @access Public
export const getGoals = async (req, res, next) => {
  try {
    const goals = await Goal.find();

    res.status(200).json({ success: true, count: goals.length, data: goals });
  } catch (err) {
    res.status(400).json({ success: false });
  }
};

Testing Our GET Request in Postman

Open Postman
Create a new HTTP Request
Add the following information to the request
1. URL: http://localhost:5000/api/v1/goals
2. Method: GET
Click Send and you will get a response of 200 OK which means everything went okay and you will get a list of goals displayed back to you.

GET (Read) - Get Single Goal

Creating Our GET Request

We need to add the following logic into our getGoal controller to have a working endpoint for our GET request:

// @desc Get single goal
// @route GET /api/v1/goals/:id
// @access Public
export const getGoal = async (req, res, next) => {
  try {
    const goal = await Goal.findById(req.params.id);

    if (!goal) {
      return res.status(400).json({ success: false });
    }

    res.status(200).json({ success: true, data: goal });
  } catch (error) {
    res.status(400).json({ success: false });
  }
};

Testing Our GET Request in Postman

Open Postman
Create a new HTTP Request
Add the following information to the request
1. URL: http://localhost:5000/api/v1/goals/653fac8d0d988dfba8a35e76
2. Method: GET
Click Send and you will get a response of 200 OK which means everything went okay and you will get a single goal displayed back to you depending on the id you chose.

PUT (Update) - Update Goal

Creating Our PUT Request

We need to add the following logic into our updateGoal controller to have a working endpoint for our PUT request:

// @desc Update goal
// @route PUT /api/v1/goals/:id
// @access Private
export const updateGoal = async (req, res, next) => {
  try {
    const goal = await Goal.findByIdAndUpdate(req.params.id, req.body, {
      new: true,
      runValidators: true,
    });

    if (!goal) {
      return res.status(400).json({ success: false });
    }

    res.status(200).json({ success: true, data: goal });
  } catch (err) {
    res.status(400).json({
      success: false,
    });
  }
};

Testing Our PUT Request in Postman

Open Postman
Create a new HTTP Request
Add the following information to the request
1. URL: http://localhost:5000/api/v1/goals/653fafc50d988dfba8a35e7a
2. Method: PUT
3. Headers: 'Content-Type': 'application/json'
4. Body (raw JSON):
```
{
    "status": "In Progress"
}
```
Click Send and you will get a response of 200 OK which means you have successfully updated an existing record and it will also be updated in your database.

DELETE (Delete) - Delete Goal

Creating Our DELETE Request

We need to add the following logic into our deleteGoal controller to have a working endpoint for our DELETE request:

// @desc Delete goal
// @route DELETE /api/v1/goals/:id
// @access Private
export const deleteGoal = async (req, res, next) => {
  try {
    const goal = await Goal.findByIdAndDelete(req.params.id);

    if (!goal) {
      return res.status(400).json({ success: false });
    }

    res.status(200).json({ success: true, data: {} });
  } catch (err) {
    res.status(400).json({
      success: false,
    });
  }
};

Testing Our DELETE Request in Postman

Open Postman
Create a new HTTP Request
Add the following information to the request
1. URL: http://localhost:5000/api/v1/goals/653fac8d0d988dfba8a35e76
2. Method: DELETE
Click Send and you will get a response of 200 OK which means you have successfully deleted a record from your database.

In summary, building a REST API with Node.js is a rewarding endeavour that requires understanding RESTful principles, error handling, and security measures. Leveraging tools like Express.js and staying updated with the latest trends is crucial.

Thanks for reading!

Have a question? Connect with me via Twitter or send me a message at hello@dylansleith.com

Supercharge Your Productivity with Postman!

Dylan 💻 — Tue, 13 Jun 2023 12:54:12 +0000

Before we get started talking about how you can improve your productivity and workflow, let's have a look at what Postman is.

Postman is an API Platform for developers to design, build, test and iterate their APIs.

Now that we know what Postman is, let’s have a look at how we can improve your productivity!

1. Collections

A collection is a group of requests which are connected to the same API. Using these we can easily organize our HTTP requests into separate folders so that we know which one does what.

Creating collections

Select Collections in the sidebar, then select +.
Select New, then select Collection.
With Collections open in the left sidebar, select +.
In an empty workspace, select Create Collection.
You can also create a collection from a template.

2. Setting and Using Variables

Variables enable you to store and reuse values in Postman. By storing a value as a variable, you can reference it throughout your collections, environments, requests, and test scripts.

Setting and using variables

Highlight any part of the URL in the request that you want to set as a variable, then click Set as variable.
Now, click Set as new variable and set the following information:
Now click Set variable and you are done setting a variable!
To use the variable, replace your the URL in the request with your variable.

http://localhost:5000/api/v1/status => {{baseUrl}}/status

3. Editing Variables

To edit a variable, do the following: (You can also add variables here)

Hover over your collection name and click the hotdog menu.
Now, click the variables tab

Variable:
- The name of your variables
Initial value:
- This value is shared with your team when you share the variable in a collection, environment or globals.
- Example: If you share this collection with anyone, they will be able to see the Initial value
Current value:
- This value is used when sending a request
- This is what is currently being used in Postman and is private to use

4. Postman variables (Global, Environment)

Global and Environment variables work just like regular variables but with Global variables you can use the variable across all of your collections and with Environment variables you can use it depending on what environment (development, production) you are on.

To create and use a Global variable, do the following:

Select the environment quick look (eye) icon on the top right of the screen.
Next to Globals, select Edit (or Add if no variables have been added yet).
Add a variable named baseUrl and give it an initial value and a current value of https://simple-books-api.glitch.me.
Open a new request tab and enter {{baseUrl}} as the URL. Hover over the variable name to inspect the variable's value and scope.

To create and use an Environment variable, do the following:

Select Environments in the sidebar, then select +.
Rename the environment to ProjectName - Development or ProjectName - Production
Add a variable named baseUrl and give it an initial value and a current value of https://simple-books-api.glitch.me.
To use the environment, select No Environment at the top right of the screen and then choose the environment that you just created.

5. Bonus Tip

Have you ever been in a situation where, when you authenticate a user using a login endpoint such as /auth/login, you have to keep copying and pasting the Bearer Token into your other endpoints to be able to use them?

Well, to solve that issue, it is quite easy. To help you stop wasting time and to auto populate the token for you, you will have to do the following:

Find your login endpoint, in this case we will use:

{{baseUrl}}/auth/login

Input your username/password into the Body in JSON format.
Click on the tab Tests and set the following information:

const json = JSON.parse(responseBody);
postman.setEnvironmentVariable("token", json.token);

You are done! Now whenever you send a HTTP request to your login endpoint, it will set/update the environment variable for token.

Thanks for reading!

Have a question? Connect with me via Twitter or send me a message at hello@dylansleith.com

Elevate Your Windows 11 Terminal: A Guide to Awesomeness!

Dylan 💻 — Mon, 22 May 2023 17:29:06 +0000

When developing applications we are always using the terminal, so why not make it look half-decent by using themes and plugins to improve our workflow?

We will be using WSL2 (Windows Subsystem for Linux) to make our terminal look and feel awesome while also installing plugins to improve our productivity when using the terminal.

Let me cut to the chase and get you started on making your terminal look awesome.

Just a side note, before you get started you may need to enable virtualization on your machine.

1. Install Windows Terminal

In the Microsoft Store app on Windows, install Windows Terminal

2. Install Ubuntu

In the Microsoft Store app on Windows, install Ubuntu
Once you have installed the app, search for it and open it.
You will be asked to enter your UNIX username and password as shown below:

Once you have created your UNIX user, you will see the following:

Now we can start installing some packages!

3. Installing Zsh (Z shell)

Before we get started installing our shell, let's resynchronize the package index files from their sources by typing sudo apt update in the command line.
Now, let's install Zsh using sudo apt install zsh -y

4. Installing Oh My Zsh

If we want to be able to install custom themes and plugins we will need to install this awesome framework for Zsh called Oh My Zsh.

First, let’s install cURL using sudo apt-get install curl
Now, type the following to install Oh My Zsh:

   sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

At this point your terminal should look like this:

5. Configuring Our Windows Terminal

Before we continue to install our custom themes and plugins, let’s change our settings in our Windows Terminal.

First, let’s head over to the settings in our Windows Terminal

Now, under Profiles, click “Add a new profile”
Select the dropdown for “Duplicate a profile” and choose “Ubuntu"

Now, just click the blue “Duplicate” button.
You can now click into your new “Ubuntu” profile that you just created and edit the name and starting directory for now.
1. For the name, I just changed “Ubuntu (Copy)” to “Ubuntu”
2. For the working directory, I changed this to where I keep all of the projects that I work on.
  1. NOTE: When using Linux C:\dev will instead be /mnt/c/dev

Now let’s start changing the look of our terminal. Scroll down to the bottom of the profile that you created and click “Appearance”.

I will be changing the “Color scheme” to a color palette that I use across multiple programs which is called Nord. I will also be changing the “Font face” to Fira Code and the “Font size” to 13
1. NOTE: You should download Fira Code or any other Nerd Font to make sure icons show when you install custom themes.

  - To download a font go to [nerdfonts.com](https://www.nerdfonts.com/font-downloads)

Now, we just need to change two more settings to be done with configuring the terminal. Scroll down until you see “Transparency” change the “Background opacity” to 70% and make sure “Enable acrylic material” is set to On.

At this point our terminal should look like this, will probably be a different color depending on what color scheme you choose

6. Installing A Minimalistic Theme

For our theme, we will be installing spaceship-prompt. This is a great theme as it is very minimal and clean.

First, we need to clone it

   git clone https://github.com/spaceship-prompt/spaceship-prompt.git "$ZSH_CUSTOM/themes/spaceship-prompt" --depth=1

Now we need to Symlink spaceship.zsh-theme to your oh-my-zsh custom themes directory:

   ln -s "$ZSH_CUSTOM/themes/spaceship-prompt/spaceship.zsh-theme" "$ZSH_CUSTOM/themes/spaceship.zsh-theme"

Now we need to edit our .zshrc file, type the following to edit our config in VSCode

   code ~/.zshrc

Set ZSH_THEME="spaceship" in your .zshrc
Now, at the bottom of your .zshrc copy and paste the following spaceship-prompt options:

   # spaceship-prompt options
   SPACESHIP_PROMPT_ADD_NEWLINE="true"
   SPACESHIP_CHAR_SYMBOL=" \\uf0e7"
   SPACESHIP_CHAR_SUFFIX=(" ")
   SPACESHIP_CHAR_COLOR_SUCCESS="yellow"
   SPACESHIP_PROMPT_DEFAULT_PREFIX="$USER"
   SPACESHIP_PROMPT_FIRST_PREFIX_SHOW="true"
   SPACESHIP_USER_SHOW="true"

   export LS_COLORS="di=34;40:ln=36;40:so=35;40:pi=33;40:ex=32;40:bd=1;33;40:cd=1;33;40:su=0;41:sg=0;43:tw=0;42:ow=34;40:"
   zstyle ':completion:*:default' list-colors ${(s.:.)LS_COLORS}

Great, we are almost there now, all we need to do is to download some awesome plugins for better productivity

7. Installing Plugins

There are a lot of plugins for Zsh so I will only show you how to install one plugin using Oh My Zsh.

The top plugins that people install are zsh-autosuggestions, zsh-syntax-highlighting, etc so let's install zsh-autosuggestions

First, type the following:

   git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

Now we need to edit our .zshrc file, type the following to edit our config in VSCode

   code ~/.zshrc

Now we need to say which plugin we would like to load:

   plugins=(git zsh-autosuggestions)

As you can see now we are getting a suggestion on what we may want in our code editor.

Congrats🎉 You are done with making your terminal look superior, I hope you will find this useful and use something like this going forward since it definitely does make your time in the terminal more fun.

Thanks for reading!

Have a question? Connect with me via Twitter or send me a message at hello@dylansleith.com