feat: added get-people, with people files

src/people/dao/people.dao.ts

+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { from, map, Observable } from 'rxjs';
+/*import { CreatePeopleDto } from '../dto/create-people.dto';
+import { UpdatePeopleDto } from '../dto/update-people.dto';*/
+import { People } from '../schemas/people.schema';
+
+@Injectable()
+export class PeopleDao {
+  constructor(
+    @InjectModel(People.name)
+    private readonly _groupModel: Model<People>,
+  ) {}
+
+  find = (): Observable<People[]> =>
+    from(this._groupModel.find({})).pipe(map((people) => [].concat(people)));
+
+}
\ No newline at end of file

src/people/entities/people.entity.ts

+import { People } from '../schemas/people.schema';
+
+export class PeopleEntity {
+    
+  constructor(partial: Partial<People>) {
+    Object.assign(this, partial);
+  }
+}
\ No newline at end of file

src/people/people.controller.ts

+import {
+    Controller,
+    Get,
+    Post,
+    Put,
+    Delete,
+    Param,
+    Body,
+    UseInterceptors,
+  } from '@nestjs/common';
+  import { Observable } from 'rxjs';
+//    import { HttpInterceptor } from '../interceptors/http.interceptor';
+//   import { CreatePeopleDto } from './dto/create-people.dto';
+//   import { UpdatePeopleDto } from './dto/update-people.dto';
+  import { PeopleEntity } from './entities/people.entity';
+  import { PeopleService } from './people.service';
+  
+
+  @Controller('people')
+//   @UseInterceptors(HttpInterceptor)
+  export class PeopleController {
+    constructor(private readonly _peopleService: PeopleService) {}
+  
+    @Get()
+    findAll(): Observable<PeopleEntity[] | void> {
+      return this._peopleService.findAll();
+    }
+  
+  }
\ No newline at end of file

src/people/people.service.ts

+import {
+    Injectable,
+    UnprocessableEntityException,
+    NotFoundException,
+    ConflictException,
+  } from '@nestjs/common';
+  import {
+    Observable,
+    of,
+    filter,
+    map,
+    mergeMap,
+    defaultIfEmpty,
+    catchError,
+    throwError,
+  } from 'rxjs';
+import { PeopleDao } from './dao/people.dao';
+//    import { HttpInterceptor } from '../interceptors/http.interceptor';
+//   import { CreatePeopleDto } from './dto/create-people.dto';
+//   import { UpdatePeopleDto } from './dto/update-people.dto';
+import { PeopleEntity } from './entities/people.entity';
+
+  
+  @Injectable()
+  export class PeopleService {
+    constructor(private readonly _peopleDao: PeopleDao) {}
+  
+    findAll = (): Observable<PeopleEntity[] | void> =>
+      this._peopleDao.find().pipe(
+        filter(Boolean),
+        map((people) => (people || []).map((person) => new PeopleEntity(person))),
+        defaultIfEmpty(undefined),
+      );
+}
\ No newline at end of file

src/people/people.types.ts

+export type Group = {
+    _id: any;
+    firstname: string,
+    lastname: string,
+    email: string,
+    passwordHash: string,
+    role: number,
+    groups: string[]
+  };

src/people/schemas/people.schema.ts

+import {
+    Prop, raw, Schema, SchemaFactory,
+} from '@nestjs/mongoose';
+import * as mongoose from 'mongoose';
+
+@Schema({
+    toJSON: {
+        virtuals: true,
+        transform: (dpc: any, ret: any) => { 
+            delete ret._id;
+        },
+    },
+    versionKey: false,
+
+})
+export class People {
+    @Prop({
+        type: mongoose.Schema.Types.ObjectId,
+        auto: true,
+    }) _id: any;
+
+    @Prop({
+        type: String,
+        required: true,
+        trim: true,
+        minlength: 2,
+    }) firstname: string;
+
+    @Prop({
+        type: String,
+        required: true,
+        trim: true,
+        minlength: 2,
+    }) lastname: string;
+
+    @Prop({
+        type: String,
+        required: true,
+        trim: true,
+        minlength: 2,
+    }) email: string;
+
+    @Prop({
+        type: String,
+        required: true,
+        trim: true,
+        minlength: 2,
+    }) passwordHash: string;
+
+    @Prop({
+        type: Number,
+        required: true,
+    }) role: string;
+
+    @Prop({
+        type: [String],
+        required: true,
+    }) groups: string[];
+
+}
+
+export const PeopleSchema = SchemaFactory.createForClass(People);
+
+PeopleSchema.index({ name: 1 }, { unique: true });
\ No newline at end of file