Gain insights into Node.js, Express, and TypeScript advantages. Learn Docker setup for PostgreSQL, discover Prisma and TypeORM, and explore advanced ORM features via hands-on projects.

ORM-libraries-for-NodeJS-Typescript-and-SQL.png

ORM.tar.gz

node-server

typeorm-setup

docker-prisma

basic-api

basic-express

typeorm-crud

typeorm-SQL

typeorm-associations

Object Relational Mappers (ORM) are becoming popular in building modern backend applications as they help maintain a consistent codebase, improve security, and provide ease in working with different databases. Also, TypeScript has almost become a must-use language for building JavaScript applications.

In this course, you’ll start by getting familiar with Node.js and Express. You’ll then go over the main features of TypeScript and its advantages over JavaScript. Next, you’ll learn how to do a Docker setup of PostgreSQL. Moreover, this will be followed by introductions to two of the most popular TypeScript ORMs for Node.js: Prisma and TypeORM. Along the way, you’ll practice your skills by building two projects. In the end, you’ll explore some advanced features of these ORMs.

This course will equip you with the skills, knowledge, and hands-on experience to work with SQL databases and Node.js using TypeScript ORMs.

Getting Started with TypeScript ORM Libraries for Node.js

Prisma is a popular and stable library with an active community contributing to building TypeScript’s back-end applications. Among the ORMs used in the industry, Prisma happens to be one of the best. It uses regular JavaScript objects and can interact with any SQL database.

// create employee
const new_employee = await prisma.employee.create({
  data: {
    employee_name: 'Alice',
    employee_email: 'alice@prisma.io',
  },
})

# Features of Prisma

## Models

Prisma has a very unique structure. It provides a model that enables a well-outlined structure, defining how our database columns interact with each other.

```
//schema.prisma

datasource db {
  url      = env("DATABASE_URL")
  provider = "postgresql"
}

generator client {
  provider = "prisma-client-js"  
}

model Employee {

  id Int @default(autoincrement()) @id
  email String  @unique
  name  String?
}

```
<p align="center"> 
Prisma schema
 </p>

A key part of the Prisma schema is the `model`. The `model` maps to the table created in the database, similarly to how we defined  `Employee` above. The parts of this `model` are called `fields`.

There are two major, supported `field` types:

- **Scalar:** Scalar data types are the regular data types (for example, `String` and `Int`.)
- **Model:** A field can have a `model` as a `field` type, and this is used to define relationships.

The Prisma schema also introduces `attributes`. These attributes map the column value to the native database data type. A few of these are:
- `@unique`: Used to declare a column value as unique.

- `@default`: Used to set a default value for the column.
- `@VarChar(x)`: Used to declare a character length for the column with `x` representing the character length.
- `@id`: Sets the column as the primary `id` column for that given model or table.




## API Interface

Another important feature is the **Prisma client**, which provides an interface for communicating with the database and carrying out queries.


Learn about Prisma and how it provides first-class support for TypeScript and makes working with different SQL databases easy and straightforward.

Course Overview

Node.js Features and Setup

TypeScript Features and Setup

SQL – Introduction and Setup

Understanding ORMs for Node.js

Prisma

Flight Booking System

TypeORM

Advanced Topics

School Grading System

Conclusion

Introduction to Prisma