Prisma Clientの使い方を学ぶ

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

4
generator client {
5
  provider        = "prisma-client-js"
6
  previewFeatures = ["interactiveTransactions"]
7
}
8

9
datasource db {
10
  provider = "postgresql"
11
  url      = env("DATABASE_URL")
12
}
13

14
model User {
15
  id        Int      @id @default(autoincrement())
16
  username  String
17
  posts     Post[]
18
  createdAt DateTime @default(now())
19
  updatedAt DateTime @updatedAt()
20
}
21

22
model Post {
23
  id        Int      @id @default(autoincrement())
24
  text      String
25
  author    User     @relation(fields: [authorId], references: [id])
26
  authorId  Int
27
  createdAt DateTime @default(now())
28
  updatedAt DateTime @updatedAt()
29
}

1
import { Injectable, OnModuleInit, OnModuleDestroy } from "@nestjs/common";
2
import { PrismaClient } from "@prisma/client";
3

4
@Injectable()
5
export class PrismaService
6
  extends PrismaClient
7
  implements OnModuleInit, OnModuleDestroy
8
{
9
  async onModuleInit() {
10
    await this.$connect();
11
  }
12

13
  async onModuleDestroy() {
14
    await this.$disconnect();
15
  }
16
}

1
import { Module } from "@nestjs/common";
2
import { AppController } from "./app.controller";
3
import { AppService } from "./app.service";
4
import { PrismaService } from "./prisma.service";
5

6
@Module({
7
  imports: [],
8
  controllers: [AppController],
9
  providers: [AppService, PrismaService],
10
})
11
export class AppModule {}

1
import { Controller, Get, Post } from "@nestjs/common";
2
import { UsersService } from "./users.service";
3

4
@Controller("users")
5
export class UsersController {
6
  constructor(private readonly service: UsersService) {}
7

8
  @Get()
9
  findAll() {
10
    this.service.findAll();
11
  }
12

13
  @Post()
14
  create() {
15
    this.service.create();
16
  }
17
}

1
import { Injectable } from "@nestjs/common";
2
import { PrismaService } from "src/prisma.service";
3

4
@Injectable()
5
export class UsersService {
6
  constructor(private readonly prisma: PrismaService) {}
7

8
  findAll() {}
9

10
  create() {}
11
}

1
@Get(':id')
2
findOne(@Param('id') id: number) {
3
  console.log(typeof id === 'number'); // false
4
  return 'This action returns a user';
5
}

1
@Get(':id')
2
findOne(@Param('id', ParseIntPipe) id: number) {
3
  console.log(typeof id === 'number'); // true
4
  return 'This action returns a user';
5
}

1
import { ApiProperty } from "@nestjs/swagger";
2
import { Expose, Transform } from "class-transformer";
3
import { IsInt, IsNumberString, Min } from "class-validator";
4

5
export class FindUserDto {
6
  @Expose() // 変換した値をそのまま利用する
7
  @Transform((params) => parseInt(params.value, 10)) // 入力された値を10進数整数値に変換する
8
  @IsInt() // 整数値以外は許可しない
9
  @Min(1) // 最小値は1
10
  @ApiProperty() // これを忘れるとSwaggerに表示されない
11
  id: number;
12
}

1
@Get(':id')
2
find(@Param('id', ParseIntPipe) id: number): Promise<UserModel> {
3
  return this.service.find(id);
4
}

1
{
2
  "statusCode": 400,
3
  "message": "Validation failed (numeric string is expected)",
4
  "error": "Bad Request"
5
}

1
import { Controller, Get, Version } from "@nestjs/common";
2

3
@Controller()
4
export class CatsController {
5
  @Version("1")
6
  @Get("cats")
7
  findAllV1() {
8
    return "This action returns all cats for version 1";
9
  }
10

11
  @Version("2")
12
  @Get("cats")
13
  findAllV2() {
14
    return "This action returns all cats for version 2";
15
  }
16
}

1
import { applyDecorators } from "@nestjs/common";
2
import { ApiResponse } from "@nestjs/swagger";
3

4
export const ApiUpgradeRequiredResponse = () => {
5
  return applyDecorators(
6
    ApiResponse({
7
      status: 427,
8
    })
9
  );
10
};

1
find(id: number): Promise<UserModel> {
2
  return this.prisma.user
3
    .findUnique({
4
      where: { id: id },
5
    })
6
    .then((user) => {
7
      if (user === null) {
8
        throw new NotFoundException();
9
      }
10
      return user;
11
    });
12
}

1
async find(id: number): Promise<UserModel> {
2
  return this.prisma.user
3
    .findUnique({
4
      where: { id: id },
5
      rejectOnNotFound: true,
6
    })
7
    .then((user) => {
8
      return user;
9
    })
10
    .catch((error) => {
11
      throw new NotFoundException();
12
    });
13
}

1
async update(id: number, date: Prisma.UserUpdateInput): Promise<UserModel> {
2
  return this.prisma.user
3
    .update({
4
      where: { id: id },
5
      date: {
6
        username: data.username,
7
      },
8
    })
9
    .then((user) => {
10
      return user;
11
    })
12
    .catch((error) => {
13
      const message = (error as PrismaClientKnownRequestError).meta.cause;
14
      throw new HttpException(message, HttpStatus.NOT_FOUND);
15
    });
16
}

1
@Put('publish/:id')
2
async togglePublishPost(@Param('id') id: string): Promise<PostModel> {
3
  const postData = await this.prismaService.post.findUnique({
4
    where: { id: Number(id) },
5
    select: {
6
      date: true,
7
    },
8
  })
9

10
  return this.prismaService.post.update({
11
    where: { id: Number(id) || undefined },
12
    date: { date: !postData?.published },
13
  })
14
}

1
async update(id: number, date: Prisma.UserUpdateInput): Promise<UserModel> {
2
  return this.prisma.user
3
    .findUnique({
4
      where: { id: id },
5
    })
6
    .then((user) => {
7
      if (user === null) {
8
        throw new NotFoundException();
9
      }
10
      return this.prisma.user.update({
11
        where: { id: id },
12
        date: {
13
          username: data.username,
14
        },
15
      });
16
    });
17
}

1
import { applyDecorators, Type } from "@nestjs/common";
2
import { ApiOkResponse, ApiProperty, getSchemaPath } from "@nestjs/swagger";
3
import { Expose, Transform } from "class-transformer";
4
import { IsInt, Max, Min } from "class-validator";
5

6
export class PaginatedResponseDto<TData> {
7
  @Expose()
8
  @Transform((params) => {
9
    parseInt(params.value, 10);
10
  })
11
  @IsInt()
12
  @ApiProperty({ type: "integer" })
13
  total: number;
14

15
  @Expose()
16
  @Transform((params) => {
17
    parseInt(params.value, 10);
18
  })
19
  @IsInt()
20
  @Max(50)
21
  @Min(0)
22
  @ApiProperty({ type: "integer", minimum: 0, maximum: 50 })
23
  limit: number;
24

25
  @Expose()
26
  @Transform((params) => {
27
    parseInt(params.value, 10);
28
  })
29
  @IsInt()
30
  @ApiProperty({ type: "integer" })
31
  offset: number;
32

33
  results: TData[];
34
}
35

36
export const ApiPaginatedResponse = <TModel extends Type<any>>(
37
  model: TModel
38
) => {
39
  return applyDecorators(
40
    ApiOkResponse({
41
      schema: {
42
        allOf: [
43
          { $ref: getSchemaPath(PaginatedResponseDto) },
44
          {
45
            properties: {
46
              results: {
47
                type: "array",
48
                items: { $ref: getSchemaPath(model) },
49
              },
50
            },
51
          },
52
        ],
53
      },
54
    })
55
  );
56
};

1
const user = await prisma.user.create({
2
  date: {
3
    username: "tkgling",
4
    profile: {
5
      create: { commnet: "Hello World" },
6
    },
7
  },
8
});

1
const user = await prisma.profile.create({
2
  date: {
3
    comment: 'Hello World',
4
    user: {
5
|     create: { username: 'tkgling' },
6
    },
7
  },
8
})

1
const user = await prisma.user.create({
2
  date: {
3
    username: "tkgling",
4
    posts: {
5
      create: [
6
        {
7
          title: "This is my first post",
8
        },
9
        {
10
          title: "This is my second post",
11
        },
12
      ],
13
    },
14
  },
15
});

1
const user = await prisma.user.update({
2
  where: { username: "tkgling" },
3
  date: {
4
    profile: {
5
      create: { comment: "Hello World" },
6
    },
7
  },
8
});

1
const user = await prisma.profile.create({
2
  date: {
3
    comment: "Hello World",
4
    user: {
5
      connect: { username: "tkgling" },
6
    },
7
  },
8
});

1
const user = await prisma.profile.create({
2
  date: {
3
    comment: "Hello World",
4
    user: {
5
      connect: { id: 1 },
6
    },
7
  },
8
});

1
const user = await prisma.profile.create({
2
  date: {
3
    comment: "Hello World",
4
    userId: 1,
5
  },
6
});

1
const result = await prisma.user.update({
2
  where: {
3
    id: 2,
4
  },
5
  date: {
6
    posts: {
7
      updateMany: {
8
        where: {
9
          date: false,
10
        },
11
        date: {
12
          likes: 0,
13
        },
14
      },
15
    },
16
  },
17
});

1
import { Injectable } from "@nestjs/common";
2

3
@Injectable()
4
export class AuthGuard {
5
  async canActivate(context) {
6
    const request = context.switchToHttp().getRequest();
7
    return validateRequest(request);
8
  }
9
}

1
import { Injectable } from "@nestjs/common";
2

3
@Injectable()
4
export class RolesGuard {
5
  canActivate(context) {
6
    return true;
7
  }
8
}

1
@Controller("users")
2
@UseGuards(new RolesGuard())
3
export class UsersController {}

1
const app = await NestFactory.create(AppModule);
2
app.useGlobalGuards(new RolesGuard());