**Apa itu Cache?**
Cache adalah mekanisme penyimpanan sementara yang digunakan untuk menyimpan data yang sering diakses agar dapat diambil dengan lebih cepat.

\
**Berikut adalah beberapa kelebihan penggunaan cache:**

&nbsp;

**Peningkatan Kinerja:**

Caching memungkinkan akses cepat ke data yang sering digunakan. Dengan menyimpan salinan data yang sering diakses di dalam cache, aplikasi dapat menghindari biaya waktu dan sumber daya yang terkait dengan mengambil data dari sumber aslinya.

&nbsp;

**Responsivitas yang Lebih Baik:**
Dengan mengambil data dari cache daripada sumber aslinya, waktu respons aplikasi dapat dipercepat secara signifikan. Hal ini meningkatkan pengalaman pengguna dan membuat aplikasi terasa lebih responsif.

&nbsp;

**Pengurangan Beban Sumber Daya:**
Penggunaan cache membantu mengurangi beban pada sumber daya, seperti database atau layanan eksternal. Dengan menghindari eksekusi query atau permintaan ke sumber data utama, cache dapat membantu mengurangi tekanan pada sistem.


\
**Cache dengan redis**

\
Redis adalah salah satu sistem penyimpanan data berkinerja tinggi yang sering digunakan sebagai cache.

\
Data dalam Redis disimpan di dalam memori (in-memory storage). Hal ini memungkinkan Redis memberikan performa tinggi karena akses ke data lebih cepat dibandingkan dengan penyimpanan di disk.

\
**Penggunaan Cache Redis di dalam Nest JS**


\
**Buat Project Nest JS**

\
Jalankan perintah

```shell
nest new nest-cache-redis
```

\
Kemudian masuk ke project

```shell
cd nest-cache-redis
```


## Database & Prisma

**Persiapan Database**


Buat docker-compose.yml

&nbsp;
```shell
version: '3.9'
services:
  db:
    image: postgres:15.3
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
    ports:
      - '5432:5432'
```

\
Kemudian jalankan perintah

&nbsp;
```shell
docker compose up --build
```

**Prisma**

\
Install Prisma

```shell
yarn add -D prisma
```

Kemudian jalankan

```shell
yarn prisma init
```

Kemudian setting koneksi database didalam .env file


```shell
DATABASE_URL="postgresql://postgres:postgres@localhost:5432/postgres?schema=public"
```

Lalu edi file prisma/schema.prisma buat model user yang nantinya menjadi table user


```javascript
// This is your Prisma schema file,
// learn more about it in the docs: https://pris.ly/d/prisma-schema

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

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

model User {
  id Int @id @default(autoincrement())

  email String @unique

  name String?
}

```

Kemudian jalankan perintah

```shell
yarn prisma migrate dev
```

\
Buat nama migrationnya misal table_user

\
![MjjMYjr.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/Mjj_M_Yjr_c7bae68fb3.png)

\
Kemudian check menggunakan **dbeaver**

![zeH4X2F.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/ze_H4_X2_F_ea826d588a.png)

\
Kemudian tambahkan contoh data user

\
![EXqLpf8.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/E_Xq_Lpf8_d28a7fc5b5.png)

\
Lalu buat api sederhana

\
di dalam **app.service.ts** buat fungsi untuk menampilkan users


&nbsp;
```javascript
import { Injectable } from '@nestjs/common';

import { PrismaClient } from '@prisma/client';


@Injectable()
export class AppService {

  private db = new PrismaClient();

  getHello(): string {
    return 'Hello World!';
  }


 async  getUsers() {
    return this.db.user.findMany();
  }

}

```

\
Lalu pada controller **app.controller.ts**

```javascript
import { Controller, Get } from '@nestjs/common';
import { AppService } from './app.service';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) { }

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }

  @Get('users')
  async getUsers() {
    return await this.appService.getUsers();
  }
}

```

\
Test API users

![Gbh6KDC.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/Gbh6_KDC_d371dffe60.png)


\
Kemudian buat cache

## Cache Dengan Redis

**Persiapan Redis**

\
Edit docker-compose.yml dan tambahkan service redis

```javascript
version: '3.9'

services:
  db:
    image: postgres:15.3
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
    ports:
      - '5432:5432'

  redis:
    image: redis
    ports:
      - 6379:6379
```

\
Jalankan ulang docker compose

```shell
docker compose up --build
```

\
**Buat module & service cache**

jalankan perintah

```shell
yarn nest g mo libs/cache
yarn nest g s libs/cache
```

### Install Cache Manager dan Redis

\
jalankan perintah

```shell
yarn add @nestjs/cache-manager cache-manager
yarn add redis cache-manager-redis-store
```

\
**edit cache.module.ts**


```javascript
import { Module } from '@nestjs/common';
import { CacheService } from './cache.service';
import { CacheModule as CacheMdl } from '@nestjs/cache-manager';
import type { RedisClientOptions } from 'redis';
const redisStore = require('cache-manager-redis-store').redisStore;
@Module({
  imports: [
    CacheMdl.register<RedisClientOptions>({
      store: redisStore,
      url: "redis://localhost:6379"
    }),
  ],
  providers: [CacheService],
  exports:[CacheService]
})
export class CacheModule { }
```

\
Kemudian edit cache.service.ts

\
Buat fungsi **setCache** dan **getCache**


```javascript
import { CACHE_MANAGER } from '@nestjs/cache-manager';
import { Inject, Injectable } from '@nestjs/common';
import { Cache } from 'cache-manager';

@Injectable()
export class CacheService {

    constructor(@Inject(CACHE_MANAGER) private cacheManager: Cache) { }

    /**
     * Set cache
     * @param key 
     * @param value 
     * @param ttl 
     */
    async setCache(key: string, value: any, ttl: number = 1000) {
        return await this.cacheManager.set(key, value, ttl)
    }

    /**
     * Get cache by key
     * @param key 
     */
    async getCache(key: string) {
        return await this.cacheManager.get(key);
    }

}

```

## Penggunaan Cache

edit **app.service.ts**

```javascript
import { CacheService } from './libs/cache/cache.service';
```

&nbsp;
```javascript
constructor(private cache: CacheService){}
```

&nbsp;
Pada fungsi getUsers

&nbsp;
```javascript
  async getUsers() {
    const key = 'users';
    if (await this.cache.getCache(key)) {
      return await this.cache.getCache(key)
    }
    const users = await this.db.user.findMany();
    if(users){
      await this.cache.setCache(key, users, 10000);
    }
    return users;
  }
```

\
Kemudian hit API

![0TYpEHb.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/0_T_Yp_E_Hb_e4ca79cac6.png)

\
Check cache redis dengan menggunakan Redis Insight

\
![SUhnt0P.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/S_Uhnt0_P_1663ba93df.png)

&nbsp;

## Repository

[https://github.com/mister-coding/nestjs-cache-redis-postgre-prisma](https://github.com/mister-coding/nestjs-cache-redis-postgre-prisma)




NestJS adalah sebuah framework untuk membuat aplikasi server-side (back-end) dengan menggunakan bahasa pemrograman TypeScript, yang dibangun di atas platform Node.js.

Meningkatkan perfoma API dengan Cache menggunakan Redis dengan contoh menggunakan Database PostgreSQL dan Prisma