<h1>เริ่มต้นใช้งาน Prisma กับ TypeScript: ORM ยุคใหม่ที่ Developer หลงรัก</h1>
<p>สวัสดีครับเพื่อนๆ นักพัฒนา! วันนี้เรามาทำความรู้จักกับ Prisma กัน ผมเพิ่งได้ลองใช้ Prisma ในโปรเจคล่าสุด และต้องบอกว่าประทับใจมากๆ เลยอยากมาแชร์ประสบการณ์ให้ฟังกัน</p>
<h2>Prisma คืออะไร?</h2>
<p>Prisma เป็น ORM (Object-Relational Mapping) ยุคใหม่ที่ออกแบบมาเพื่อทำให้การทำงานกับฐานข้อมูลง่ายขึ้น โดยเฉพาะเมื่อใช้คู่กับ TypeScript ข้อดีของ Prisma คือ:</p>
<ol>
<li>Type-safe: ให้ TypeScript type ที่แม่นยำ</li>
<li>Auto-completion ที่ดีเยี่ยม</li>
<li>การ migrate ฐานข้อมูลที่ง่ายดาย</li>
<li>Query ที่อ่านง่ายและมีประสิทธิภาพ</li>
</ol>
<h2>เริ่มต้นใช้งาน Prisma กับ TypeScript</h2>
<h3>1. ติดตั้ง Prisma</h3>
<p>เริ่มจากการติดตั้ง Prisma CLI และ dependencies:</p>
<pre><code class="language-bash">npm install prisma --save-dev
npm install @prisma/client
</code></pre>
<h3>2. เริ่มต้นโปรเจค Prisma</h3>
<pre><code class="language-bash">npx prisma init
</code></pre>
<p>คำสั่งนี้จะสร้างไฟล์ <code>prisma/schema.prisma</code> และ <code>.env</code></p>
<h3>3. กำหนด Schema</h3>
<p>แก้ไขไฟล์ <code>prisma/schema.prisma</code> เพื่อกำหนดโครงสร้างฐานข้อมูล:</p>
<pre><code class="language-prisma">datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

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

model User {
  id    Int     @id @default(autoincrement())
  email String  @unique
  name  String?
  posts Post[]
}

model Post {
  id        Int     @id @default(autoincrement())
  title     String
  content   String?
  published Boolean @default(false)
  author    User    @relation(fields: [authorId], references: [id])
  authorId  Int
}
</code></pre>
<h3>4. สร้างและใช้งาน Prisma Client</h3>
<p>สร้างไฟล์ <code>src/db.ts</code>:</p>
<pre><code class="language-typescript">import { PrismaClient } from '@prisma/client'

const prisma = new PrismaClient()

export default prisma
</code></pre>
<h3>5. ใช้งาน Prisma ในโค้ด</h3>
<p>ตัวอย่างการใช้งาน Prisma ใน TypeScript:</p>
<pre><code class="language-typescript">import prisma from './db'

async function main() {
    // สร้าง User ใหม่
    const newUser = await prisma.user.create({
        data: {
            email: 'john@example.com',
            name: 'John Doe',
        },
    })
    console.log('New user:', newUser)

    // ค้นหา User ทั้งหมด
    const allUsers = await prisma.user.findMany()
    console.log('All users:', allUsers)

    // สร้าง Post และเชื่อมกับ User
    const newPost = await prisma.post.create({
        data: {
            title: 'My first post',
            content: 'This is the content of my first post',
            author: {
                connect: { id: newUser.id },
            },
        },
    })
    console.log('New post:', newPost)

    // ค้นหา Post พร้อมข้อมูล User
    const postWithAuthor = await prisma.post.findUnique({
        where: { id: newPost.id },
        include: { author: true },
    })
    console.log('Post with author:', postWithAuthor)
}

main()
    .catch((e) => console.error(e))
    .finally(async () => await prisma.$disconnect())
</code></pre>
<h2>Tips &#x26; Tricks</h2>
<ol>
<li>
<p><strong>ใช้ Prisma Studio</strong>: Prisma มีเครื่องมือ GUI ชื่อ Prisma Studio ที่ช่วยให้เราจัดการข้อมูลได้ง่ายๆ</p>
<pre><code class="language-bash">npx prisma studio
</code></pre>
</li>
<li>
<p><strong>Migrations</strong>: ใช้ Prisma Migrate เพื่อจัดการการเปลี่ยนแปลงโครงสร้างฐานข้อมูล</p>
<pre><code class="language-bash">npx prisma migrate dev --name init
</code></pre>
</li>
<li>
<p><strong>Seeding Data</strong>: สร้างไฟล์ <code>prisma/seed.ts</code> เพื่อเพิ่มข้อมูลตั้งต้น</p>
<pre><code class="language-typescript">import prisma from '../src/db'

async function main() {
    const alice = await prisma.user.upsert({
        where: { email: 'alice@prisma.io' },
        update: {},
        create: {
            email: 'alice@prisma.io',
            name: 'Alice',
            posts: {
                create: {
                    title: 'Check out Prisma with Next.js',
                    content: 'https://www.prisma.io/nextjs',
                    published: true,
                },
            },
        },
    })
    console.log({ alice })
}

main()
    .catch((e) => console.error(e))
    .finally(async () => await prisma.$disconnect())
</code></pre>
</li>
<li>
<p><strong>Middleware</strong>: ใช้ Prisma middleware เพื่อเพิ่มลอจิกก่อนหรือหลังการ query</p>
<pre><code class="language-typescript">prisma.$use(async (params, next) => {
    const before = Date.now()
    const result = await next(params)
    const after = Date.now()
    console.log(
        `Query ${params.model}.${params.action} took ${after - before}ms`,
    )
    return result
})
</code></pre>
</li>
</ol>
<h2>สรุป</h2>
<p>Prisma เป็น ORM ที่ทรงพลังและใช้งานง่าย โดยเฉพาะเมื่อใช้คู่กับ TypeScript ช่วยให้เราทำงานกับฐานข้อมูลได้อย่างมีประสิทธิภาพ ลดข้อผิดพลาด และเพิ่มความเร็วในการพัฒนา</p>
<p>ผมหวังว่าบทความนี้จะช่วยให้คุณเริ่มต้นใช้งาน Prisma ได้อย่างราบรื่นนะครับ ถ้ามีคำถามหรืออยากแชร์ประสบการณ์ก็คอมเมนต์มาได้เลย! Happy coding ครับ 😊</p>



# เริ่มต้นใช้งาน Prisma กับ TypeScript: ORM ยุคใหม่ที่ Developer หลงรัก

สวัสดีครับเพื่อนๆ นักพัฒนา! วันนี้เรามาทำความรู้จักกับ Prisma กัน ผมเพิ่งได้ลองใช้ Prisma ในโปรเจคล่าสุด และต้องบอกว่าประทับใจมากๆ เลยอยากมาแชร์ประสบการณ์ให้ฟังกัน

## Prisma คืออะไร?

Prisma เป็น ORM (Object-Relational Mapping) ยุคใหม่ที่ออกแบบมาเพื่อทำให้การทำงานกับฐานข้อมูลง่ายขึ้น โดยเฉพาะเมื่อใช้คู่กับ TypeScript ข้อดีของ Prisma คือ:

1. Type-safe: ให้ TypeScript type ที่แม่นยำ
2. Auto-completion ที่ดีเยี่ยม
3. การ migrate ฐานข้อมูลที่ง่ายดาย
4. Query ที่อ่านง่ายและมีประสิทธิภาพ

## เริ่มต้นใช้งาน Prisma กับ TypeScript

### 1. ติดตั้ง Prisma

เริ่มจากการติดตั้ง Prisma CLI และ dependencies:

```bash
npm install prisma --save-dev
npm install @prisma/client
```

### 2. เริ่มต้นโปรเจค Prisma

```bash
npx prisma init
```

คำสั่งนี้จะสร้างไฟล์ `prisma/schema.prisma` และ `.env`

### 3. กำหนด Schema

แก้ไขไฟล์ `prisma/schema.prisma` เพื่อกำหนดโครงสร้างฐานข้อมูล:

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

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

model User {
  id    Int     @id @default(autoincrement())
  email String  @unique
  name  String?
  posts Post[]
}

model Post {
  id        Int     @id @default(autoincrement())
  title     String
  content   String?
  published Boolean @default(false)
  author    User    @relation(fields: [authorId], references: [id])
  authorId  Int
}
```

### 4. สร้างและใช้งาน Prisma Client

สร้างไฟล์ `src/db.ts`:

```typescript
import { PrismaClient } from '@prisma/client'

const prisma = new PrismaClient()

export default prisma
```

### 5. ใช้งาน Prisma ในโค้ด

ตัวอย่างการใช้งาน Prisma ใน TypeScript:

```typescript
import prisma from './db'

async function main() {
    // สร้าง User ใหม่
    const newUser = await prisma.user.create({
        data: {
            email: 'john@example.com',
            name: 'John Doe',
        },
    })
    console.log('New user:', newUser)

    // ค้นหา User ทั้งหมด
    const allUsers = await prisma.user.findMany()
    console.log('All users:', allUsers)

    // สร้าง Post และเชื่อมกับ User
    const newPost = await prisma.post.create({
        data: {
            title: 'My first post',
            content: 'This is the content of my first post',
            author: {
                connect: { id: newUser.id },
            },
        },
    })
    console.log('New post:', newPost)

    // ค้นหา Post พร้อมข้อมูล User
    const postWithAuthor = await prisma.post.findUnique({
        where: { id: newPost.id },
        include: { author: true },
    })
    console.log('Post with author:', postWithAuthor)
}

main()
    .catch((e) => console.error(e))
    .finally(async () => await prisma.$disconnect())
```

## Tips & Tricks

1. **ใช้ Prisma Studio**: Prisma มีเครื่องมือ GUI ชื่อ Prisma Studio ที่ช่วยให้เราจัดการข้อมูลได้ง่ายๆ

    ```bash
    npx prisma studio
    ```

2. **Migrations**: ใช้ Prisma Migrate เพื่อจัดการการเปลี่ยนแปลงโครงสร้างฐานข้อมูล

    ```bash
    npx prisma migrate dev --name init
    ```

3. **Seeding Data**: สร้างไฟล์ `prisma/seed.ts` เพื่อเพิ่มข้อมูลตั้งต้น

    ```typescript
    import prisma from '../src/db'

    async function main() {
        const alice = await prisma.user.upsert({
            where: { email: 'alice@prisma.io' },
            update: {},
            create: {
                email: 'alice@prisma.io',
                name: 'Alice',
                posts: {
                    create: {
                        title: 'Check out Prisma with Next.js',
                        content: 'https://www.prisma.io/nextjs',
                        published: true,
                    },
                },
            },
        })
        console.log({ alice })
    }

    main()
        .catch((e) => console.error(e))
        .finally(async () => await prisma.$disconnect())
    ```

4. **Middleware**: ใช้ Prisma middleware เพื่อเพิ่มลอจิกก่อนหรือหลังการ query
    ```typescript
    prisma.$use(async (params, next) => {
        const before = Date.now()
        const result = await next(params)
        const after = Date.now()
        console.log(
            `Query ${params.model}.${params.action} took ${after - before}ms`,
        )
        return result
    })
    ```

## สรุป

Prisma เป็น ORM ที่ทรงพลังและใช้งานง่าย โดยเฉพาะเมื่อใช้คู่กับ TypeScript ช่วยให้เราทำงานกับฐานข้อมูลได้อย่างมีประสิทธิภาพ ลดข้อผิดพลาด และเพิ่มความเร็วในการพัฒนา

ผมหวังว่าบทความนี้จะช่วยให้คุณเริ่มต้นใช้งาน Prisma ได้อย่างราบรื่นนะครับ ถ้ามีคำถามหรืออยากแชร์ประสบการณ์ก็คอมเมนต์มาได้เลย! Happy coding ครับ 😊


เรียนรู้วิธีการใช้งาน Prisma ร่วมกับ TypeScript ตั้งแต่การติดตั้ง การตั้งค่า ไปจนถึงการใช้งานพื้นฐาน พร้อมตัวอย่างโค้ดและเทคนิคการใช้งาน

เริ่มต้นใช้งาน Prisma กับ TypeScript: ORM ยุคใหม่ที่ Developer หลงรัก

<h2>แนวทางการเขียนโค้ดฝั่ง Backend ด้วย NestJS ให้ Maintain ง่าย</h2>
<p>การเขียนโค้ดฝั่ง backend ให้สามารถบำรุงรักษาได้ง่ายและมีความยืดหยุ่นเป็นสิ่งที่จำเป็น โดยเฉพาะเมื่อโค้ดนั้นเติบโตขึ้นเรื่อย ๆ การแยกส่วน (separation of concerns) จึงเป็นแนวทางที่ดีในการทำให้โค้ดดูแลรักษาได้ง่ายขึ้น ในบทความนี้ ผมจะแนะนำแนวทางพื้นฐานในการจัดการโค้ดฝั่ง backend ด้วย <strong>NestJS</strong> โดยใช้การแยก layer ออกเป็น <strong>Controller</strong>, <strong>Service</strong>, และ <strong>Repository</strong> ซึ่งจะช่วยทำให้โค้ดของเรามีความเป็นระเบียบและยืดหยุ่นต่อการแก้ไขในอนาคต</p>
<h3>1. Controller: จัดการ Request-Response</h3>
<p>ใน <strong>NestJS</strong> เราจะใช้ <strong>Controller</strong> ในการจัดการกับ HTTP request และ response ซึ่งถือว่าเป็นชั้นที่ใกล้ชิดกับผู้ใช้มากที่สุด ดังนั้นภารกิจหลักของ Controller คือการรับ request, ดึงข้อมูลจาก query, body, params หรือ headers จากนั้นจึงส่ง response กลับไปยัง client</p>
<p>ในส่วนนี้เราควรแยกการจัดการกับ <strong>status code</strong> เช่น การส่ง response แบบ error หรือ success ให้อยู่ใน Controller โดยไม่ไปปะปนกับ logic อื่น ๆ</p>
<pre><code class="language-typescript">// user.controller.ts
import { Controller, Get, Param, Query, Res } from '@nestjs/common';
import { UserService } from './user.service';

@Controller('user')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Get(':id')
  async getUserById(@Param('id') id: string, @Res() res) {
    try {
      const user = await this.userService.getUserById(id);
      return res.status(200).json(user);
    } catch (error) {
      return res.status(404).json({ message: 'User not found' });
    }
  }
}
</code></pre>
<p>แนวทางสำคัญ: การ extract ข้อมูล เช่น params, query หรือ body ควรทำในชั้น Controller นี้เท่านั้น อย่าผสมกับ logic ในชั้นอื่น เพื่อให้แต่ละ layer มีหน้าที่ชัดเจน</p>
<h3>2. Service: การประมวลผลและการติดต่อกับ Third Party</h3>
<p>ในส่วนของ Service คือชั้นที่ใช้จัดการกับ business logic ของแอปพลิเคชัน หรือการทำงานเบื้องหลังที่ซับซ้อนกว่าการรับ-ส่งข้อมูล การใช้ Service จะทำให้ Controller ไม่ต้องจัดการกับงานที่ซับซ้อนเกินไป ซึ่งทำให้โค้ดในแต่ละชั้นชัดเจนขึ้น</p>
<p>Service อาจเรียกใช้ข้อมูลจาก Repository หรือทำงานร่วมกับ third party APIs ได้ การใช้ Service จะช่วยแยก logic ออกจาก Controller ทำให้ Controller ไม่ยุ่งเหยิงจนเกินไป</p>
<pre><code class="language-typescript">// user.service.ts
import { Injectable } from '@nestjs/common';
import { UserRepository } from './user.repository';

@Injectable()
export class UserService {
    constructor(private readonly userRepository: UserRepository) {}

    async getUserById(id: string) {
        return this.userRepository.findById(id);
    }
}
</code></pre>
<p>แนวทางสำคัญ: ควรแยกฟังก์ชันการประมวลผลบางอย่าง (เช่น การ transform ข้อมูล) โดยเขียนให้เป็น pure function ไปไว้ที่ utility functions เพื่อให้สามารถเขียนเทสได้ง่าย และทำให้ Service มีความชัดเจนมากขึ้น</p>
<h3>3. Repository: การดึงข้อมูลจากแหล่งข้อมูล</h3>
<pre><code class="language-typescript">// user.repository.ts
import { Injectable } from '@nestjs.common';

@Injectable()
export class UserRepository {
  private users = [{ id: '1', name: 'John' }, { id: '2', name: 'Jane' }];

  async findById(id: string) {
    return this.users.find(user => user.id === id);
  }
}
</code></pre>
<p>แนวทางสำคัญ: Repository ทำหน้าที่ติดต่อกับฐานข้อมูลเท่านั้น ไม่ควรมี business logic หรือการประมวลผลข้อมูลซับซ้อนเกินไป</p>
<hr>
<p>การแยก Controller, Service, และ Repository ออกจากกันใน NestJS ช่วยทำให้โค้ดมีความชัดเจน มีความยืดหยุ่นในการดูแลและปรับปรุง รวมทั้งทำให้การเขียนเทสง่ายขึ้น การจัดโครงสร้างโค้ดแบบนี้ยังช่วยให้ทีมงานสามารถทำงานร่วมกันได้อย่างมีประสิทธิภาพมากขึ้นด้วยครับ</p>



## แนวทางการเขียนโค้ดฝั่ง Backend ด้วย NestJS ให้ Maintain ง่าย

การเขียนโค้ดฝั่ง backend ให้สามารถบำรุงรักษาได้ง่ายและมีความยืดหยุ่นเป็นสิ่งที่จำเป็น โดยเฉพาะเมื่อโค้ดนั้นเติบโตขึ้นเรื่อย ๆ การแยกส่วน (separation of concerns) จึงเป็นแนวทางที่ดีในการทำให้โค้ดดูแลรักษาได้ง่ายขึ้น ในบทความนี้ ผมจะแนะนำแนวทางพื้นฐานในการจัดการโค้ดฝั่ง backend ด้วย **NestJS** โดยใช้การแยก layer ออกเป็น **Controller**, **Service**, และ **Repository** ซึ่งจะช่วยทำให้โค้ดของเรามีความเป็นระเบียบและยืดหยุ่นต่อการแก้ไขในอนาคต

### 1. Controller: จัดการ Request-Response

ใน **NestJS** เราจะใช้ **Controller** ในการจัดการกับ HTTP request และ response ซึ่งถือว่าเป็นชั้นที่ใกล้ชิดกับผู้ใช้มากที่สุด ดังนั้นภารกิจหลักของ Controller คือการรับ request, ดึงข้อมูลจาก query, body, params หรือ headers จากนั้นจึงส่ง response กลับไปยัง client

ในส่วนนี้เราควรแยกการจัดการกับ **status code** เช่น การส่ง response แบบ error หรือ success ให้อยู่ใน Controller โดยไม่ไปปะปนกับ logic อื่น ๆ

```typescript
// user.controller.ts
import { Controller, Get, Param, Query, Res } from '@nestjs/common';
import { UserService } from './user.service';

@Controller('user')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Get(':id')
  async getUserById(@Param('id') id: string, @Res() res) {
    try {
      const user = await this.userService.getUserById(id);
      return res.status(200).json(user);
    } catch (error) {
      return res.status(404).json({ message: 'User not found' });
    }
  }
}
```

แนวทางสำคัญ: การ extract ข้อมูล เช่น params, query หรือ body ควรทำในชั้น Controller นี้เท่านั้น อย่าผสมกับ logic ในชั้นอื่น เพื่อให้แต่ละ layer มีหน้าที่ชัดเจน

### 2. Service: การประมวลผลและการติดต่อกับ Third Party

ในส่วนของ Service คือชั้นที่ใช้จัดการกับ business logic ของแอปพลิเคชัน หรือการทำงานเบื้องหลังที่ซับซ้อนกว่าการรับ-ส่งข้อมูล การใช้ Service จะทำให้ Controller ไม่ต้องจัดการกับงานที่ซับซ้อนเกินไป ซึ่งทำให้โค้ดในแต่ละชั้นชัดเจนขึ้น

Service อาจเรียกใช้ข้อมูลจาก Repository หรือทำงานร่วมกับ third party APIs ได้ การใช้ Service จะช่วยแยก logic ออกจาก Controller ทำให้ Controller ไม่ยุ่งเหยิงจนเกินไป

```typescript
// user.service.ts
import { Injectable } from '@nestjs/common';
import { UserRepository } from './user.repository';

@Injectable()
export class UserService {
    constructor(private readonly userRepository: UserRepository) {}

    async getUserById(id: string) {
        return this.userRepository.findById(id);
    }
}
```

แนวทางสำคัญ: ควรแยกฟังก์ชันการประมวลผลบางอย่าง (เช่น การ transform ข้อมูล) โดยเขียนให้เป็น pure function ไปไว้ที่ utility functions เพื่อให้สามารถเขียนเทสได้ง่าย และทำให้ Service มีความชัดเจนมากขึ้น

### 3. Repository: การดึงข้อมูลจากแหล่งข้อมูล

```typescript
// user.repository.ts
import { Injectable } from '@nestjs.common';

@Injectable()
export class UserRepository {
  private users = [{ id: '1', name: 'John' }, { id: '2', name: 'Jane' }];

  async findById(id: string) {
    return this.users.find(user => user.id === id);
  }
}
```

แนวทางสำคัญ: Repository ทำหน้าที่ติดต่อกับฐานข้อมูลเท่านั้น ไม่ควรมี business logic หรือการประมวลผลข้อมูลซับซ้อนเกินไป

---

การแยก Controller, Service, และ Repository ออกจากกันใน NestJS ช่วยทำให้โค้ดมีความชัดเจน มีความยืดหยุ่นในการดูแลและปรับปรุง รวมทั้งทำให้การเขียนเทสง่ายขึ้น การจัดโครงสร้างโค้ดแบบนี้ยังช่วยให้ทีมงานสามารถทำงานร่วมกันได้อย่างมีประสิทธิภาพมากขึ้นด้วยครับ


แนวทางการจัดการโค้ดฝั่ง backend ใน NestJS เพื่อให้ดูแลรักษาง่าย โดยการแยก layer ออกเป็น Controller, Service, และ Repository

แนวทางการเขียนโค้ดฝั่ง Backend ด้วย NestJS ให้ Maintain ง่าย

เนื้อหาเกี่ยวกับการพัฒนา Backend, API และการจัดการเซิร์ฟเวอร์ด้วย Node.js