Nodejs Nestjs Typegoose插件@nestjs/typegoose的使用

Nodejs Nestjs Typegoose插件@nestjs/typegoose的使用
[@nestjs](/user/nestjs)/typegoose 是一个用于在 NestJS 项目中与 Mongoose 数据库交互的库。它允许你使用 Typegoose（一个用于将 TypeScript 类转换为 Mongoose Schema 的库）来定义你的数据模型。

下面是如何在 NestJS 项目中使用 [@nestjs](/user/nestjs)/typegoose 和 Typegoose 的步骤：

安装依赖

首先，你需要安装必要的依赖包：

npm install [@nestjs](/user/nestjs)/typegoose mongoose typegoose

创建模块

创建一个 NestJS 模块，并导入 TypegooseModule：

import { Module } from '[@nestjs](/user/nestjs)/common';
import { TypegooseModule } from '[@nestjs](/user/nestjs)/typegoose';

@Module({
  imports: [
    TypegooseModule.forRoot('mongodb://localhost/test'),
    // 在这里添加其他需要的模块
  ],
})
export class AppModule {}

定义数据模型

使用 Typegoose 定义一个数据模型：

import { prop, getModelForClass } from '@typegoose/typegoose';

class User {
  @prop()
  name: string;

  @prop({ unique: true })
  email: string;
}

const UserModel = getModelForClass(User);

export { User, UserModel };

创建服务

创建一个服务来处理数据库操作：

import { Injectable } from '[@nestjs](/user/nestjs)/common';
import { InjectModel } from '[@nestjs](/user/nestjs)/typegoose';
import { User, UserModel } from './user.model';

@Injectable()
export class UserService {
  constructor(
    @InjectModel(User) private readonly userModel: typeof UserModel,
  ) {}

  async create(user: User): Promise<User> {
    return this.userModel.create(user);
  }

  async findAll(): Promise<User[]> {
    return this.userModel.find().exec();
  }

  async findOne(email: string): Promise<User | null> {
    return this.userModel.findOne({ email }).exec();
  }

  async update(email: string, user: User): Promise<User | null> {
    return this.userModel.findOneAndUpdate({ email }, user, { new: true }).exec();
  }

  async delete(email: string): Promise<void> {
    await this.userModel.deleteOne({ email }).exec();
  }
}

创建控制器

创建一个控制器来处理 HTTP 请求：

import { Controller, Get, Post, Body, Param, Put, Delete } from '[@nestjs](/user/nestjs)/common';
import { UserService } from './user.service';
import { User } from './user.model';

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

  @Post()
  async create(@Body() user: User): Promise<User> {
    return this.userService.create(user);
  }

  @Get()
  async findAll(): Promise<User[]> {
    return this.userService.findAll();
  }

  @Get(':email')
  async findOne(@Param('email') email: string): Promise<User | null> {
    return this.userService.findOne(email);
  }

  @Put(':email')
  async update(@Param('email') email: string, @Body() user: User): Promise<User | null> {
    return this.userService.update(email, user);
  }

  @Delete(':email')
  async delete(@Param('email') email: string): Promise<void> {
    return this.userService.delete(email);
  }
}

配置模块

确保在你的模块中声明了 UserService 和 UserController：

import { Module } from '[@nestjs](/user/nestjs)/common';
import { TypegooseModule } from '[@nestjs](/user/nestjs)/typegoose';
import { User, UserModel } from './user.model';
import { UserService } from './user.service';
import { UserController } from './user.controller';

@Module({
  imports: [
    TypegooseModule.forFeature([User]),
  ],
  providers: [UserService],
  controllers: [UserController],
})
export class UserModule {}

这样，你就完成了在 NestJS 项目中使用 [@nestjs](/user/nestjs)/typegoose 的基本配置。你可以根据需要调整这些代码以满足你的具体需求。


3 回复

当然，让我用一种轻松的方式给你介绍一下@nestjs/typegoose这个插件吧！

想象一下，你在烘焙一个超级美味的蛋糕（我们的项目），但是这个蛋糕需要一些特别的材料（我们的数据库模型）。Typegoose就像是那个神奇的配方书，帮你把JavaScript类变成MongoDB可以理解的模型。而@nestjs/typegoose则是那把魔法钥匙，让你可以在NestJS的世界里，轻松地打开Typegoose的大门。

首先，你需要安装它：

npm install @nestjs/typegoosemongoose

然后，在你的模块中导入TypegooseModule，就像这样：

import { TypegooseModule } from '@nestjs/typegoose';

@Module({
  imports: [
    TypegooseModule.forFeature([
      { typegooseClass: YourModelClass, schemaOptions: { collection: 'your-models' } },
    ]),
  ],
})
export class ApplicationModule {}

现在，你可以愉快地定义你的模型类了，就像定义一个普通的TypeScript类一样，但别忘了添加一些装饰器魔法，比如@prop()来定义字段。

希望这能帮到你，开始你的魔法之旅吧！


@nestjs/typegoose 是一个用于将 Typegoose 集成到 NestJS 应用程序中的库。Typegoose 允许你在 TypeScript 中使用装饰器来定义 Mongoose 模型，从而提高类型安全性和开发体验。

以下是如何在 NestJS 项目中使用 @nestjs/typegoose 的基本步骤和示例代码：

安装必要的包

首先，你需要安装 @nestjs/typegoose 和相关的依赖包：

npm install @nestjs/typegoose mongoose

配置 TypegooseModule

在你的 NestJS 应用程序中，你需要配置 TypegooseModule。通常情况下，这会在你的根模块（例如 AppModule）中完成。

import { Module } from '@nestjs/common';
import { TypegooseModule } from '@nestjs/typegoose';
import { User } from './models/user.model';

@Module({
  imports: [
    TypegooseModule.forRoot('mongodb://localhost/testdb'),
    TypegooseModule.forFeature([User])
  ],
  controllers: [],
  providers: [],
})
export class AppModule {}

这里，TypegooseModule.forRoot() 用于连接到 MongoDB 数据库，而 TypegooseModule.forFeature() 用于注册模型。

定义模型

接下来，你可以创建一个模型文件，比如 user.model.ts:

import { prop, getModelForClass } from '@typegoose/typegoose';

export class User {
  @prop()
  name: string;

  @prop({ required: true })
  email: string;
}

export const UserModel = getModelForClass(User);

在这个例子中，我们定义了一个简单的 User 类，并使用了 @typegoose/typegoose 提供的装饰器来指定字段属性。

使用模型

现在你可以在服务或控制器中使用这个模型。下面是一个简单的服务示例：

import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/typegoose';
import { User } from './models/user.model';
import { ReturnModelType } from '@typegoose/typegoose';

@Injectable()
export class UserService {
  constructor(
    @InjectModel(User) private readonly userModel: ReturnModelType<typeof User>,
  ) {}

  async create(user: User): Promise<User> {
    return this.userModel.create(user);
  }

  async findAll(): Promise<User[]> {
    return this.userModel.find().exec();
  }
}

以上就是在 NestJS 中使用 @nestjs/typegoose 的基本流程。这种方式结合了 NestJS 的依赖注入系统和 Typegoose 的类型安全特性，使得在 NestJS 应用中操作数据库变得更加方便和高效。

@nestjs/typegoose 是用于 NestJS 框架的 Typegoose 集成。首先安装 @nestjs/typegoose 和 typegoose：

npm install @nestjs/typegoose typegoose mongoose

创建一个服务并注入 TypegooseModule：

import { Injectable } from '@nestjs/common';
import { ReturnModelType } from '@typegoose/typegoose/lib/types';
import { InjectModel } from '@nestjs/typegoose';
import { YourModel } from './your.model';

@Injectable()
export class YourService {
  constructor(
    @InjectModel(YourModel) private readonly model: ReturnModelType<typeof YourModel>,
  ) {}

  async create(entity: YourModel): Promise<YourModel> {
    return this.model.create(entity);
  }
}

在模块中导入 TypegooseModule：

import { Module } from '@nestjs/common';
import { TypegooseModule } from '@nestjs/typegoose';
import { YourService } from './your.service';
import { YourModel } from './your.model';

@Module({
  imports: [
    TypegooseModule.forFeature([YourModel]),
  ],
  providers: [YourService],
  exports: [YourService],
})
export class YourModule {}

这样你就可以使用 Typegoose 进行数据库操作了。

回到顶部