Merge pull request #2 from ivanalglave/crud-groups

Crud groups

package.json

@@ -29,6 +29,9 @@
     "@nestjs/core": "^9.0.0",
     "@nestjs/mongoose": "^9.2.1",
     "@nestjs/platform-express": "^9.0.0",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.13.2",
+    "fastify": "^4.9.2",
     "mongoose": "^6.7.2",
     "reflect-metadata": "^0.1.13",
     "rimraf": "^3.0.2",

src/app.module.ts

 import { Module } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
 import { mongodb } from './config';
+import { GroupsModule } from './groups/groups.module';
 
 @Module({
-  imports: [MongooseModule.forRoot(mongodb.uri)],
-  controllers: [],
-  providers: [],
+  imports: [GroupsModule, MongooseModule.forRoot(mongodb.uri)],
 })
 export class AppModule {}

src/groups/dao/groups.dao.ts

+import {
+  Injectable,
+  NotFoundException,
+  InternalServerErrorException,
+} from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { CreateGroupDto } from '../dto/create-group.dto';
+import { UpdateGroupDto } from '../dto/update-group.dto';
+import { Group } from '../schemas/group.schema';
+
+@Injectable()
+export class GroupsDao {
+  constructor(
+    @InjectModel(Group.name)
+    private readonly _groupModel: Model<Group>,
+  ) {}
+
+  find = (): Promise<Group[]> =>
+    new Promise((resolve, reject) => {
+      this._groupModel.find({}, {}, {}, (err, value) => {
+        if (err) reject(err.message);
+        if (!value) reject('No values');
+        resolve(value);
+      });
+    });
+
+  findById = (id: string): Promise<Group | void> =>
+    new Promise((resolve, reject) => {
+      this._groupModel.findOne({ id: id }, {}, {}, (err, value) => {
+        if (err) reject(err.message);
+        if (!value) reject(new NotFoundException());
+        resolve(value);
+      });
+    });
+
+  save = (group: CreateGroupDto): Promise<Group> =>
+    new Promise((resolve, reject) => {
+      new this._groupModel(group).save((err, value) => {
+        if (err) reject(err.message);
+        if (!value) reject(new InternalServerErrorException());
+        resolve(value);
+      });
+    });
+
+  findByIdAndUpdate = (
+    id: string,
+    group: UpdateGroupDto,
+  ): Promise<Group | void> =>
+    new Promise((resolve, reject) => {
+      this._groupModel.updateOne(
+        { id: id },
+        group,
+        {
+          new: true,
+          runValidators: true,
+        },
+        (err, value) => {
+          if (err) reject(err.message);
+          if (value.matchedCount === 0) reject(new NotFoundException());
+          resolve(value);
+        },
+      );
+    });
+
+  findByIdAndRemove = (id: string): Promise<Group | void> =>
+    new Promise((resolve, reject) => {
+      this._groupModel.deleteOne({ id: id }, {}, (err) => {
+        if (err) reject(err.message);
+        resolve();
+      });
+    });
+}

src/groups/dto/create-group.dto.ts

+import { IsBoolean, IsString, IsNotEmpty } from 'class-validator';
+
+export class CreateGroupDto {
+  @IsString()
+  @IsNotEmpty()
+  id: string;
+
+  @IsBoolean()
+  final: boolean;
+
+  @IsString()
+  @IsNotEmpty()
+  parent: any;
+}

src/groups/dto/update-group.dto.ts

+import { IsArray, IsOptional } from 'class-validator';
+
+export class UpdateGroupDto {
+  @IsArray()
+  @IsOptional()
+  responsibles: string[];
+
+  @IsArray()
+  @IsOptional()
+  secretaries: string[];
+
+  @IsArray()
+  @IsOptional()
+  students: string[];
+}

src/groups/entities/group.entity.ts

+import { Group } from '../schemas/group.schema';
+
+export class GroupEntity {
+  _id: string;
+  id: string;
+  final: boolean;
+  responsibles: string[];
+  secretaries: string[];
+  students: string[];
+  parent: string;
+
+  constructor(partial: Partial<Group>) {
+    Object.assign(this, partial);
+  }
+}

src/groups/groups.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 { CreateGroupDto } from './dto/create-group.dto';
+import { UpdateGroupDto } from './dto/update-group.dto';
+import { GroupEntity } from './entities/group.entity';
+import { GroupsService } from './groups.service';
+
+@Controller('groups')
+@UseInterceptors(HttpInterceptor)
+export class GroupsController {
+  constructor(private readonly _groupsService: GroupsService) {}
+
+  @Get()
+  findAll(): Promise<GroupEntity[] | void> {
+    return this._groupsService.findAll();
+  }
+
+  @Get(':id')
+  findOne(@Param() params: { id: string }): Promise<GroupEntity | void> {
+    return this._groupsService.findOne(params.id);
+  }
+
+  @Post()
+  create(@Body() createGroupDto: CreateGroupDto): Promise<GroupEntity> {
+    return this._groupsService.create(createGroupDto);
+  }
+
+  @Put(':id')
+  update(
+    @Param() params: { id: string },
+    @Body() updateGroupDto: UpdateGroupDto,
+  ): Promise<GroupEntity | void> {
+    return this._groupsService.update(params.id, updateGroupDto);
+  }
+
+  @Delete(':id')
+  delete(@Param() params: { id: string }): Promise<GroupEntity | void> {
+    return this._groupsService.delete(params.id);
+  }
+}

src/groups/groups.module.ts

+import { Module, Logger } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { GroupsDao } from './dao/groups.dao';
+import { GroupsController } from './groups.controller';
+import { GroupsService } from './groups.service';
+import { Group, GroupSchema } from './schemas/group.schema';
+
+@Module({
+  imports: [
+    MongooseModule.forFeature([{ name: Group.name, schema: GroupSchema }]),
+  ],
+  controllers: [GroupsController],
+  providers: [GroupsService, GroupsDao, Logger],
+})
+export class GroupsModule {}

src/groups/groups.service.ts

+import { Injectable } from '@nestjs/common';
+import { GroupsDao } from './dao/groups.dao';
+import { CreateGroupDto } from './dto/create-group.dto';
+import { UpdateGroupDto } from './dto/update-group.dto';
+import { GroupEntity } from './entities/group.entity';
+
+@Injectable()
+export class GroupsService {
+  constructor(private readonly _groupsDao: GroupsDao) {}
+
+  findAll = (): Promise<GroupEntity[] | void> => this._groupsDao.find();
+
+  findOne = (id: string): Promise<GroupEntity | void> =>
+    this._groupsDao.findById(id);
+
+  create = (group: CreateGroupDto): Promise<GroupEntity> =>
+    this._groupsDao.save(group);
+
+  update = (id: string, group: UpdateGroupDto): Promise<GroupEntity | void> =>
+    this._groupsDao.findByIdAndUpdate(id, group);
+
+  delete = (id: string): Promise<GroupEntity | void> =>
+    this._groupsDao.findByIdAndRemove(id);
+}

src/groups/groups.types.ts

+export type Group = {
+  _id: any;
+  id: string;
+  final: boolean;
+  responsibles: string[];
+  secretaries: string[];
+  students: string[];
+  subgroups: string[];
+  parent: string;
+};

src/groups/schemas/group.schema.ts

+import * as mongoose from 'mongoose';
+import { Document } from 'mongoose';
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+
+export type GroupDocument = Group & Document;
+
+@Schema({
+  toJSON: {
+    virtuals: true,
+    transform: (doc: any, ret: any) => {
+      delete ret._id;
+    },
+  },
+})
+export class Group {
+  @Prop({
+    type: mongoose.Schema.Types.ObjectId,
+    auto: true,
+  })
+  _id: any;
+
+  @Prop({
+    type: String,
+    required: true,
+    trim: true,
+  })
+  id: string;
+
+  @Prop({
+    type: Boolean,
+    required: true,
+    trim: true,
+  })
+  final: boolean;
+
+  @Prop({
+    type: [String],
+    required: true,
+    trim: true,
+  })
+  responsibles: string[];
+
+  @Prop({
+    type: [String],
+    required: true,
+    trim: true,
+  })
+  secretaries: string[];
+
+  @Prop({
+    type: [String],
+    required: true,
+    trim: true,
+  })
+  students: string[];
+
+  @Prop({
+    type: String,
+    required: true,
+    trim: true,
+  })
+  parent: string;
+}
+
+export const GroupSchema = SchemaFactory.createForClass(Group);
+
+GroupSchema.index({ id: 1 }, { unique: true });

src/interceptors/http.interceptor.ts

+import {
+  CallHandler,
+  ExecutionContext,
+  Injectable,
+  Logger,
+  NestInterceptor,
+} from '@nestjs/common';
+import { merge, Observable, of } from 'rxjs';
+import { filter, map, mergeMap, tap } from 'rxjs/operators';
+import { FastifyReply } from 'fastify';
+
+@Injectable()
+export class HttpInterceptor implements NestInterceptor {
+  /**
+   * Class constructor
+   * @param _logger
+   */
+  constructor(private readonly _logger: Logger) {}
+
+  /**
+   * Intercepts all HTTP requests and responses
+   *
+   * @param context
+   * @param next
+   */
+  intercept = (
+    context: ExecutionContext,
+    next: CallHandler,
+  ): Observable<any> => {
+    const cls = context.getClass();
+    const handler = context.getHandler();
+    const response: FastifyReply = context
+      .switchToHttp()
+      .getResponse<FastifyReply>();
+    const logCtx = `${cls.name}.${handler.name}`;
+
+    return next.handle().pipe(
+      map((_) => of(_)),
+      mergeMap((obs: Observable<any>) =>
+        merge(
+          obs.pipe(
+            filter((_) => !!_),
+            map((_) => _),
+          ),
+          obs.pipe(
+            filter((_) => !_),
+            tap(() => response.status(204)),
+            map((_) => _),
+          ),
+        ),
+      ),
+      tap({
+        next: (_) =>
+          this._logger.log(!!_ ? JSON.stringify(_) : 'NO CONTENT', logCtx),
+        error: (_) =>
+          this._logger.error(
+            _?.message ?? 'unspecified error',
+            JSON.stringify(_),
+            logCtx,
+          ),
+      }),
+    );
+  };
+}

src/main.ts

+import { ValidationPipe } from '@nestjs/common';
 import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
 import { server } from './config';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
+  await app.useGlobalPipes(
+    new ValidationPipe({
+      whitelist: true,
+      forbidNonWhitelisted: true,
+    }),
+  );
   await app.listen(server.port);
 }
 bootstrap();