在NestJS中使用GraphQL

1
src/
2
├── app.module.ts
3
├── main.ts
4
├── user/
5
│   ├── user.model.ts
6
│   ├── user.input.ts
7
│   ├── user.resolver.ts
8
│   ├── user.service.ts

1
import { Module } from "@nestjs/common";
2
import { GraphQLModule } from "@nestjs/graphql";
3
import { ApolloDriver, ApolloDriverConfig } from "@nestjs/apollo";
4
import { TypeOrmModule } from "@nestjs/typeorm";
5
import { join } from "path";
6
import { UserModule } from "./user/user.module";
7
import { User } from "./user/user.model";
8

9
@Module({
10
  imports: [
11
    GraphQLModule.forRoot<ApolloDriverConfig>({
12
      driver: ApolloDriver,
13
      autoSchemaFile: join(process.cwd(), "src/schema.gql"), // 自动生成 schema.gql 文件
14
    }),
15
    TypeOrmModule.forRoot({
16
      type: "mysql",
17
      host: "localhost",
18
      port: 3306,
19
      username: "root",
20
      password: "password",
21
      database: "test",
22
      entities: [User],
23
      synchronize: true,
24
    }),
25
    UserModule,
26
  ],
27
})
28
export class AppModule {}

1
import { Resolver, Query, Mutation, Args } from "@nestjs/graphql";
2
import { User } from "./user.model";
3
import { CreateUserInput } from "./user.input";
4
import { UserService } from "./user.service";
5

6
@Resolver(() => User)
7
export class UserResolver {
8
  constructor(private readonly userService: UserService) {}
9

10
  @Query(() => [User])
11
  async getUsers(): Promise<User[]> {
12
    return this.userService.getUsers();
13
  }
14

15
  @Mutation(() => User)
16
  async createUser(@Args("input") input: CreateUserInput): Promise<User> {
17
    return this.userService.createUser(input);
18
  }
19
}

1
import { Resolver, Query, Args, Int } from "@nestjs/graphql";
2
import { User } from "./user.model";
3
import { UserService } from "./user.service";
4

5
@Resolver(() => User)
6
export class UserResolver {
7
  constructor(private readonly userService: UserService) {}
8

9
  @Query(() => [User])
10
  async getUsers(
11
    @Args("page", { type: () => Int, nullable: true }) page: number = 1,
12
    @Args("limit", { type: () => Int, nullable: true }) limit: number = 10,
13
  ): Promise<User[]> {
14
    return this.userService.getUsersWithPagination(page, limit);
15
  }
16

17
  @Query(() => [User])
18
  async searchUsers(
19
    @Args("keyword", { type: () => String }) keyword: string,
20
  ): Promise<User[]> {
21
    return this.userService.searchUsers(keyword);
22
  }
23
}
24

25
// src/user/user.service.ts
26
import { Injectable } from "@nestjs/common";
27
import { InjectRepository } from "@nestjs/typeorm";
28
import { Repository } from "typeorm";
29
import { User } from "./user.model";
30
import { CreateUserInput } from "./user.input";
31

32
@Injectable()
33
export class UserService {
34
  constructor(
35
    @InjectRepository(User)
36
    private usersRepository: Repository<User>,
37
  ) {}
38

39
  async getUsers(): Promise<User[]> {
40
    return this.usersRepository.find();
41
  }
42

43
  async createUser(input: CreateUserInput): Promise<User> {
44
    const user = this.usersRepository.create(input);
45
    return this.usersRepository.save(user);
46
  }
47

48
  async getUsersWithPagination(page: number, limit: number): Promise<User[]> {
49
    const [result] = await this.usersRepository.findAndCount({
50
      skip: (page - 1) * limit,
51
      take: limit,
52
    });
53
    return result;
54
  }
55

56
  async searchUsers(keyword: string): Promise<User[]> {
57
    return this.usersRepository
58
      .createQueryBuilder("user")
59
      .where("user.name LIKE :keyword", { keyword: `%${keyword}%` })
60
      .orWhere("user.email LIKE :keyword", { keyword: `%${keyword}%` })
61
      .getMany();
62
  }
63
}