O MongoDB é um banco de dados NoSQL sem esquema com estruturas de documentos flexíveis, ao contrário dos bancos de dados SQL. Usar o MongoDB como banco de dados traz muitos benefícios, desde fácil dimensionamento até recursos modernos de banco de dados, como transações.
O MongoDB também suporta bibliotecas de modelagem de dados de objetos (ODM) como Mongoose. Os ODMs gerenciam relacionamentos de dados, validam esquemas e convertem objetos em modelos de dados. Eles facilitam a interação com um banco de dados MongoDB.
Em algumas etapas, você aprenderá a usar o MongoDB em um aplicativo NestJS com o pacote NestJS mongoose dedicado.
Etapa 1: instalando dependências
Antes de usar o Mongoose em seu aplicativo NestJS, você deve instalá-lo junto com seu pacote NestJS nativo.
Instale o mongoose e seu pacote nativo NestJS usando o gerenciador de pacotes npm Correndo:
npm instalar @nestjs/mangusto mangusto
Etapa 2: Conectando-se ao MongoDB
Quando a instalação terminar, navegue até o seu app.module.ts Arquivo. Em seguida, importe Módulo Mangusto a partir de @ninho/mangusto:
importar { MongooseModule } a partir de '@nestjs/mangusto';
Em seguida, em sua matriz de importações, chame o forRoot método em Módulo Mangusto e passe seu URI do MongoDB como um argumento:
importações: [MongooseModule.forRoot (process.env. MONGODB_URI)],
o forRoot O método compartilha a conexão com o banco de dados por meio de todos os módulos em seu aplicativo. Leva um objeto de configuração opcional; você pode aprender mais sobre isso em do mangusto documentação de opções.
Etapa 3: criando um esquema de mangusto
Um esquema é um objeto JSON que define a estrutura e o conteúdo de seus dados. Você precisará criar um para definir como o Mongoose armazena seus dados no banco de dados MongoDB.
No módulo raiz do seu aplicativo, crie um "esquemas" pasta. Esta pasta é onde você armazenará todos os seus arquivos de esquema.
Dentro do seu esquemas pasta, crie um arquivo de esquema e nomeie-o usando a convenção de nomenclatura NestJS (
Em seguida, adicione as seguintes importações ao seu arquivo de esquema:
importar { Prop, Schema, SchemaFactory } a partir de "@nestjs/mangusto";
importar { Documento } a partir de "mangusto";
o Suporte decorator marca as propriedades que anota como uma propriedade em seu banco de dados MongoDB.
o Esquema decorador marca a classe que anota como um esquema.
o SchemaFactory A classe contém métodos estáticos usados para criação de modelo.
O mangusto Documento representa um mapeamento um para um para documentos armazenados no MongoDB. Você precisará dele como uma anotação de tipo.
Então, criar uma classe, anote-o com o Esquema decorador para marcá-lo como um esquema Mongoose e exportá-lo:
@Esquema()
exportarclasseDemonstração{}
Em seguida, crie e exporte um tipo de união com sua classe e Documento:
exportarmodelo DemoDocument = Demo & Documento;
Em seguida, adicione as propriedades desejadas à classe e anote-as com o Suporte decorador. Você pode passar um objeto de configuração opcional para o Suporte decorador e defina a propriedade conforme necessário:
@Esquema()
exportarclasseDemonstração{
@Suporte({ requeridos: verdadeiro })
propriedade_1: string;
}
o Mangusto documentação cobre o objeto de configuração em mais detalhes.
Finalmente, crie e exporte um modelo Mongoose através do SchemaFactoryde createForClass e passe sua classe como um argumento:
exportarconst DemoSchema = SchemaFactory.createForClass (Demo);
Seu esquema completo deve ficar assim:
importar { Prop, Schema, SchemaFactory } a partir de '@nestjs/mangusto';
importar { Documento } a partir de 'mangusto';exportarmodelo DemoDocument = Demo & Documento;
@Esquema()
exportarclasseDemonstração{
@Suporte({ requeridos: verdadeiro })
propriedade_1: string;@Suporte({ requeridos: verdadeiro })
propriedade_2: número;@Suporte()
propriedade_3: string;@Suporte({ requeridos: verdadeiro })
propriedade_4: boleano;
}
exportarconst DemoSchema = SchemaFactory.createForClass (Demo);
Etapa 4: registrando o esquema
Navegue até a pasta do seu módulo e adicione as seguintes importações:
importar { MongooseModule } a partir de '@nestjs/mangusto';
importar { Demo, DemoSchema } a partir de '../schemas/demo.schema';
Em seguida, crie um “importações” matriz dentro do @módulo decorador. Então, dentro do array, chame o paraRecurso método em Módulo Mangusto.
o paraRecurso O método leva em uma matriz de modelos Mongoose. Passe um objeto de configuração com um nome propriedade definida para o nome de sua classe de esquema e um esquema propriedade definida para o esquema criado:
Módulo Mangusto.forRecurso([{ nome: Demo.name, esquema: DemoSchema }]),
Passo 5: Injetando o Modelo Mongoose
Em seguida, você precisará injetar o Modelo do Mongoose para habilitar a consulta do seu banco de dados chamando os métodos do Mongoose no modelo.
Navegue até a classe de serviço do seu módulo e adicione as seguintes importações:
importar { Modelo } a partir de 'mangusto';
importar { InjectModel } a partir de '@nestjs/mangusto';
importar { Demo, DemoDocument } a partir de '../schemas/demo.schema';
Use o Modelo interface como uma definição de tipo para seu modelo, dando acesso aos métodos do Mongoose.
o InjectModel decorator injeta o modelo Mongoose no construtor da sua classe de serviço.
A seguir, crie um construtor dentro de sua classe de serviço. Deve demorar um privado variável como argumento, um Modelo com um tipo genérico de DemoDocument. Anote sua variável privada com o InjectModel decorator e passe o nome da sua classe de esquema como argumento:
@Injetável()
exportarclasseServiço de demonstração{
construtor(
@InjectModel(Demo.name)
private demoModel: Model<DemoDocument>,
) {}
}
Você pode consultar seu banco de dados MongoDB chamando métodos Mongoose em sua variável privada (demoModel).
Vantagens de usar o MongoDB
Além de sua forte comunidade online e facilidade de uso, o MongoDB oferece alta disponibilidade e estabilidade de dados. Ele oferece análises aceleradas, agregação de dados e muito mais, tornando-o o banco de dados ideal para seus projetos.
