NestJSとPrisma - 型安全なデータベースクライアントの導入

1
2
3
4
5
6
7

// TypeORMの例：型安全性が不完全
const posts = await postRepository.find({
  select: ['id', 'title'],
});

// postsの型はPost[]だが、実際にはidとtitleしか含まれていない
console.log(posts[0].content); // 実行時エラー（undefinedにアクセス）

1
2
3
4
5
6
7

// Prismaの例：完全な型安全性
const posts = await prisma.post.findMany({
  select: { id: true, title: true },
});

// postsの型は { id: number; title: string }[] として推論される
console.log(posts[0].content); // コンパイルエラー（contentプロパティが存在しない）

1
2
3
4
5
6
7

// TypeORMの例
const posts = await postRepository.find({
  where: {
    views: MoreThan('test'), // 文字列を渡してもコンパイルは通る
  },
});
// 実行時エラー: invalid input syntax for type integer

1
2
3
4
5
6

// Prismaの例
const posts = await prisma.post.findMany({
  where: {
    views: { gt: 'test' }, // コンパイルエラー: 型 'string' を型 'number' に割り当てることはできません
  },
});

1

npm install prisma --save-dev

1

npx prisma init --datasource-provider postgresql

1

DATABASE_URL="postgresql://username:password@localhost:5432/nestjs_prisma?schema=public"

1

npm install @prisma/client

1

npm install @prisma/adapter-pg pg

1

npx prisma generate

1

npx prisma migrate dev --name init

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

-- CreateTable
CREATE TABLE "User" (
    "id" SERIAL NOT NULL,
    "email" TEXT NOT NULL,
    "name" TEXT,
    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
    "updatedAt" TIMESTAMP(3) NOT NULL,

    CONSTRAINT "User_pkey" PRIMARY KEY ("id")
);

-- CreateTable
CREATE TABLE "Post" (
    "id" SERIAL NOT NULL,
    "title" TEXT NOT NULL,
    "content" TEXT,
    "published" BOOLEAN NOT NULL DEFAULT false,
    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
    "updatedAt" TIMESTAMP(3) NOT NULL,
    "authorId" INTEGER NOT NULL,

    CONSTRAINT "Post_pkey" PRIMARY KEY ("id")
);

-- CreateIndex
CREATE UNIQUE INDEX "User_email_key" ON "User"("email");

-- AddForeignKey
ALTER TABLE "Post" ADD CONSTRAINT "Post_authorId_fkey" 
  FOREIGN KEY ("authorId") REFERENCES "User"("id") ON DELETE RESTRICT ON UPDATE CASCADE;

1

npx prisma migrate deploy

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// src/prisma/prisma.service.ts
import { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
import { PrismaClient } from '../generated/prisma/client';
import { PrismaPg } from '@prisma/adapter-pg';
import { Pool } from 'pg';

@Injectable()
export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
  constructor() {
    const pool = new Pool({ connectionString: process.env.DATABASE_URL });
    const adapter = new PrismaPg(pool);
    super({ adapter });
  }

  async onModuleInit() {
    await this.$connect();
  }

  async onModuleDestroy() {
    await this.$disconnect();
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// SQLiteの場合
import { PrismaBetterSqlite3 } from '@prisma/adapter-better-sqlite3';

@Injectable()
export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
  constructor() {
    const adapter = new PrismaBetterSqlite3({ url: process.env.DATABASE_URL });
    super({ adapter });
  }
  // ...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// src/prisma/prisma.module.ts
import { Global, Module } from '@nestjs/common';
import { PrismaService } from './prisma.service';

@Global()
@Module({
  providers: [PrismaService],
  exports: [PrismaService],
})
export class PrismaModule {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// src/app.module.ts
import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { PrismaModule } from './prisma/prisma.module';

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
    }),
    PrismaModule,
  ],
})
export class AppModule {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// src/users/users.service.ts
import { Injectable } from '@nestjs/common';
import { PrismaService } from '../prisma/prisma.service';
import { User, Prisma } from '../generated/prisma';

@Injectable()
export class UsersService {
  constructor(private prisma: PrismaService) {}

  async createUser(data: Prisma.UserCreateInput): Promise<User> {
    return this.prisma.user.create({
      data,
    });
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 基本的な作成
const user = await this.usersService.createUser({
  email: 'alice@example.com',
  name: 'Alice',
});

// リレーションを含む作成（ネストされた書き込み）
const userWithPosts = await this.prisma.user.create({
  data: {
    email: 'bob@example.com',
    name: 'Bob',
    posts: {
      create: [
        { title: '最初の投稿', content: 'こんにちは！' },
        { title: '2番目の投稿', published: true },
      ],
    },
  },
  include: {
    posts: true,
  },
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// 単一レコードの取得
async findUserById(id: number): Promise<User | null> {
  return this.prisma.user.findUnique({
    where: { id },
  });
}

// 複数レコードの取得
async findAllUsers(): Promise<User[]> {
  return this.prisma.user.findMany();
}

// 条件付き取得
async findUserByEmail(email: string): Promise<User | null> {
  return this.prisma.user.findUnique({
    where: { email },
  });
}

1
2
3
4
5
6

async updateUser(id: number, data: Prisma.UserUpdateInput): Promise<User> {
  return this.prisma.user.update({
    where: { id },
    data,
  });
}

1
2
3
4
5

async deleteUser(id: number): Promise<User> {
  return this.prisma.user.delete({
    where: { id },
  });
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// ユーザーと投稿を一緒に取得
async findUserWithPosts(id: number) {
  return this.prisma.user.findUnique({
    where: { id },
    include: {
      posts: true,
    },
  });
}

// ネストされたinclude
async findUserWithPublishedPosts(id: number) {
  return this.prisma.user.findUnique({
    where: { id },
    include: {
      posts: {
        where: { published: true },
        orderBy: { createdAt: 'desc' },
      },
    },
  });
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 特定のフィールドのみ取得
async findUserNames() {
  return this.prisma.user.findMany({
    select: {
      id: true,
      name: true,
      email: true,
    },
  });
}

// 戻り値の型は { id: number; name: string | null; email: string }[] として推論される

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// 複合条件でのフィルタリング
async findPosts(params: {
  skip?: number;
  take?: number;
  where?: Prisma.PostWhereInput;
  orderBy?: Prisma.PostOrderByWithRelationInput;
}) {
  const { skip, take, where, orderBy } = params;
  return this.prisma.post.findMany({
    skip,
    take,
    where,
    orderBy,
  });
}

// 使用例
const publishedPosts = await this.findPosts({
  where: {
    published: true,
    title: { contains: 'NestJS' },
  },
  orderBy: { createdAt: 'desc' },
  take: 10,
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// 投稿から著者を取得
async getPostAuthor(postId: number) {
  return this.prisma.post
    .findUnique({ where: { id: postId } })
    .author();
}

// ユーザーから投稿を取得
async getUserPosts(userId: number) {
  return this.prisma.user
    .findUnique({ where: { id: userId } })
    .posts();
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106

// src/posts/posts.service.ts
import { Injectable, NotFoundException } from '@nestjs/common';
import { PrismaService } from '../prisma/prisma.service';
import { Post, Prisma } from '../generated/prisma';

@Injectable()
export class PostsService {
  constructor(private prisma: PrismaService) {}

  async create(data: Prisma.PostCreateInput): Promise<Post> {
    return this.prisma.post.create({
      data,
      include: { author: true },
    });
  }

  async findAll(params: {
    skip?: number;
    take?: number;
    cursor?: Prisma.PostWhereUniqueInput;
    where?: Prisma.PostWhereInput;
    orderBy?: Prisma.PostOrderByWithRelationInput;
  }): Promise<Post[]> {
    const { skip, take, cursor, where, orderBy } = params;
    return this.prisma.post.findMany({
      skip,
      take,
      cursor,
      where,
      orderBy,
      include: { author: true },
    });
  }

  async findOne(id: number): Promise<Post> {
    const post = await this.prisma.post.findUnique({
      where: { id },
      include: { author: true },
    });

    if (!post) {
      throw new NotFoundException(`Post with ID ${id} not found`);
    }

    return post;
  }

  async update(id: number, data: Prisma.PostUpdateInput): Promise<Post> {
    try {
      return await this.prisma.post.update({
        where: { id },
        data,
        include: { author: true },
      });
    } catch (error) {
      if (error instanceof Prisma.PrismaClientKnownRequestError) {
        if (error.code === 'P2025') {
          throw new NotFoundException(`Post with ID ${id} not found`);
        }
      }
      throw error;
    }
  }

  async remove(id: number): Promise<Post> {
    try {
      return await this.prisma.post.delete({
        where: { id },
      });
    } catch (error) {
      if (error instanceof Prisma.PrismaClientKnownRequestError) {
        if (error.code === 'P2025') {
          throw new NotFoundException(`Post with ID ${id} not found`);
        }
      }
      throw error;
    }
  }

  async publish(id: number): Promise<Post> {
    return this.prisma.post.update({
      where: { id },
      data: { published: true },
    });
  }

  async findPublished(): Promise<Post[]> {
    return this.prisma.post.findMany({
      where: { published: true },
      include: { author: true },
      orderBy: { createdAt: 'desc' },
    });
  }

  async search(searchString: string): Promise<Post[]> {
    return this.prisma.post.findMany({
      where: {
        OR: [
          { title: { contains: searchString, mode: 'insensitive' } },
          { content: { contains: searchString, mode: 'insensitive' } },
        ],
      },
      include: { author: true },
    });
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

// src/posts/posts.controller.ts
import {
  Controller,
  Get,
  Post,
  Body,
  Patch,
  Param,
  Delete,
  Query,
  ParseIntPipe,
} from '@nestjs/common';
import { PostsService } from './posts.service';
import { Prisma } from '../generated/prisma';

@Controller('posts')
export class PostsController {
  constructor(private readonly postsService: PostsService) {}

  @Post()
  create(@Body() createPostDto: Prisma.PostCreateInput) {
    return this.postsService.create(createPostDto);
  }

  @Get()
  findAll(
    @Query('skip') skip?: string,
    @Query('take') take?: string,
    @Query('published') published?: string,
  ) {
    return this.postsService.findAll({
      skip: skip ? parseInt(skip, 10) : undefined,
      take: take ? parseInt(take, 10) : undefined,
      where: published !== undefined ? { published: published === 'true' } : undefined,
      orderBy: { createdAt: 'desc' },
    });
  }

  @Get('published')
  findPublished() {
    return this.postsService.findPublished();
  }

  @Get('search')
  search(@Query('q') query: string) {
    return this.postsService.search(query);
  }

  @Get(':id')
  findOne(@Param('id', ParseIntPipe) id: number) {
    return this.postsService.findOne(id);
  }

  @Patch(':id')
  update(
    @Param('id', ParseIntPipe) id: number,
    @Body() updatePostDto: Prisma.PostUpdateInput,
  ) {
    return this.postsService.update(id, updatePostDto);
  }

  @Patch(':id/publish')
  publish(@Param('id', ParseIntPipe) id: number) {
    return this.postsService.publish(id);
  }

  @Delete(':id')
  remove(@Param('id', ParseIntPipe) id: number) {
    return this.postsService.remove(id);
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

async transferPost(postId: number, newAuthorId: number) {
  return this.prisma.$transaction(async (tx) => {
    // 投稿が存在するか確認
    const post = await tx.post.findUnique({
      where: { id: postId },
    });

    if (!post) {
      throw new NotFoundException('Post not found');
    }

    // 新しい著者が存在するか確認
    const newAuthor = await tx.user.findUnique({
      where: { id: newAuthorId },
    });

    if (!newAuthor) {
      throw new NotFoundException('New author not found');
    }

    // 投稿の著者を更新
    return tx.post.update({
      where: { id: postId },
      data: { authorId: newAuthorId },
      include: { author: true },
    });
  });
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

async createUserWithInitialPost(userData: Prisma.UserCreateInput, postTitle: string) {
  const [user, post] = await this.prisma.$transaction([
    this.prisma.user.create({ data: userData }),
    this.prisma.post.create({
      data: {
        title: postTitle,
        author: { connect: { email: userData.email } },
      },
    }),
  ]);

  return { user, post };
}

1

npx prisma studio

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# アプリケーションの起動
npm run start:dev

# ユーザーの作成
curl -X POST http://localhost:3000/users \
  -H "Content-Type: application/json" \
  -d '{"email": "test@example.com", "name": "Test User"}'

# 投稿の作成
curl -X POST http://localhost:3000/posts \
  -H "Content-Type: application/json" \
  -d '{"title": "Hello Prisma", "content": "型安全なORM", "author": {"connect": {"email": "test@example.com"}}}'