Merge pull request #2438 from schw4rzlicht/fix/populate

fix: populate on arrays

Author: kamilmysliwiec

lib/factories/definitions.factory.ts

@@ -85,7 +85,8 @@ export class DefinitionsFactory {
       return schemaDefinition;
     } else if (
       typeof optionsOrType.type === 'function' ||
-      Array.isArray(optionsOrType.type)
+      (Array.isArray(optionsOrType.type) &&
+        typeof optionsOrType.type[0] === 'function')
     ) {
       optionsOrType.type = this.inspectTypeDefinition(optionsOrType.type);
       return optionsOrType;

tests/e2e/mongoose.spec.ts

@@ -3,6 +3,8 @@ import { Test } from '@nestjs/testing';
 import { Server } from 'http';
 import * as request from 'supertest';
 import { AppModule } from '../src/app.module';
+import { CreateCatDto } from '../src/cats/dto/create-cat.dto';
+import { Cat } from '../src/cats/schemas/cat.schema';
 
 describe('Mongoose', () => {
   let server: Server;
@@ -32,6 +34,61 @@ describe('Mongoose', () => {
       });
   });
 
+  it('should populate array of kittens', async () => {
+    let createDto: CreateCatDto = {
+      name: 'Kitten',
+      breed: 'Maine coon',
+      age: 1,
+    };
+
+    const kitten: Cat = await new Promise((resolve) => {
+      request(server)
+        .post('/cats')
+        .send(createDto)
+        .expect(201)
+        .end((err, { body }) => {
+          expect(body.name).toEqual(createDto.name);
+          expect(body.age).toEqual(createDto.age);
+          expect(body.breed).toEqual(createDto.breed);
+          resolve(body);
+        });
+    });
+
+    createDto = {
+      ...createDto,
+      name: 'Nest',
+      age: 5,
+      kitten: [kitten._id as string],
+    };
+
+    const parent = await new Promise<string>((resolve) => {
+      request(server)
+        .post('/cats')
+        .send(createDto)
+        .expect(201)
+        .end((err, { body }) => {
+          expect(body.name).toEqual(createDto.name);
+          expect(body.age).toEqual(createDto.age);
+          expect(body.breed).toEqual(createDto.breed);
+          resolve(body._id as string);
+        });
+    });
+
+    await new Promise<void>((resolve) => {
+      request(server)
+        .get(`/cat/${parent}`)
+        .expect(200)
+        .end((err, { body }) => {
+          expect(Array.isArray(body.kitten)).toBe(true);
+          expect(body.kitten[0]._id).toBe(kitten._id);
+          expect(body.kitten[0].name).toBe(kitten.name);
+          expect(body.kitten[0].breed).toBe(kitten.breed);
+          expect(body.kitten[0].age).toBe(kitten.age);
+          resolve();
+        });
+    });
+  });
+
   afterEach(async () => {
     await app.close();
   });

tests/e2e/schema.factory.spec.ts

@@ -28,6 +28,10 @@ class ExampleClass {
   @Prop()
   array: Array<any>;
 
+  // see https://github.com/nestjs/mongoose/issues/839
+  @Prop({ type: [ChildClass], required: true })
+  anotherArray: ChildClass[];
+
   @Virtual({
     options: {
       localField: 'array',

tests/src/app.module.ts

@@ -1,11 +1,13 @@
 import { Module } from '@nestjs/common';
 import { MongooseModule } from '../../lib';
 import { CatsModule } from './cats/cats.module';
+import { CatModule } from './cats/cat.module';
 
 @Module({
   imports: [
     MongooseModule.forRoot('mongodb://localhost:27017/test'),
     CatsModule,
+    CatModule,
   ],
 })
 export class AppModule {}

tests/src/cats/cat.controller.ts

@@ -0,0 +1,13 @@
+import { Controller, Get, Param } from '@nestjs/common';
+import { CatService } from './cat.service';
+import { Cat } from './schemas/cat.schema';
+
+@Controller('cat')
+export class CatController {
+  constructor(private readonly catService: CatService) {}
+
+  @Get(':id')
+  async findOne(@Param('id') id: string): Promise<Cat | null> {
+    return this.catService.findOne(id);
+  }
+}

tests/src/cats/cat.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '../../../lib';
+import { Cat, CatSchema } from './schemas/cat.schema';
+import { CatController } from './cat.controller';
+import { CatService } from './cat.service';
+
+@Module({
+  imports: [MongooseModule.forFeature([{ name: Cat.name, schema: CatSchema }])],
+  controllers: [CatController],
+  providers: [CatService],
+})
+export class CatModule {}

tests/src/cats/cat.service.ts

@@ -0,0 +1,13 @@
+import { Injectable } from '@nestjs/common';
+import { Model } from 'mongoose';
+import { InjectModel } from '../../../lib';
+import { Cat } from './schemas/cat.schema';
+
+@Injectable()
+export class CatService {
+  constructor(@InjectModel(Cat.name) private readonly catModel: Model<Cat>) {}
+
+  async findOne(id: string): Promise<Cat | null> {
+    return this.catModel.findById(id).populate('kitten').exec();
+  }
+}

tests/src/cats/cats.service.ts

@@ -1,5 +1,5 @@
 import { Injectable } from '@nestjs/common';
-import { Model } from 'mongoose';
+import { Model, Types } from 'mongoose';
 import { InjectModel } from '../../../lib';
 import { CreateCatDto } from './dto/create-cat.dto';
 import { Cat } from './schemas/cat.schema';
@@ -9,7 +9,10 @@ export class CatsService {
   constructor(@InjectModel(Cat.name) private readonly catModel: Model<Cat>) {}
 
   async create(createCatDto: CreateCatDto): Promise<Cat> {
-    const createdCat = new this.catModel(createCatDto);
+    const createdCat = new this.catModel({
+      ...createCatDto,
+      kitten: createCatDto.kitten?.map((kitten) => new Types.ObjectId(kitten)),
+    });
     return createdCat.save();
   }
 

tests/src/cats/dto/create-cat.dto.ts

@@ -2,4 +2,5 @@ export class CreateCatDto {
   readonly name: string;
   readonly age: number;
   readonly breed: string;
+  readonly kitten?: string[];
 }

tests/src/cats/schemas/cat.schema.ts

@@ -1,4 +1,4 @@
-import { Document } from 'mongoose';
+import { Document, Types } from 'mongoose';
 import { Prop, Schema, SchemaFactory } from '../../../../lib';
 
 @Schema()
@@ -11,6 +11,13 @@ export class Cat extends Document {
 
   @Prop()
   breed: string;
+
+  // see https://github.com/nestjs/mongoose/issues/2421
+  @Prop({
+    type: [{ type: Types.ObjectId, ref: Cat.name }],
+    default: [],
+  })
+  kitten: Types.ObjectId[];
 }
 
 export const CatSchema = SchemaFactory.createForClass(Cat);