@lenne.tech/nest-server 11.1.14 → 11.3.0

package/src/index.ts

@@ -34,6 +34,7 @@ export * from './core/common/helpers/decorator.helper';
 export * from './core/common/helpers/file.helper';
 export * from './core/common/helpers/filter.helper';
 export * from './core/common/helpers/graphql.helper';
+export * from './core/common/helpers/gridfs.helper';
 export * from './core/common/helpers/input.helper';
 export * from './core/common/helpers/model.helper';
 export * from './core/common/helpers/scim.helper';

package/src/main.ts

@@ -1,11 +1,19 @@
 import { NestFactory } from '@nestjs/core';
 import { NestExpressApplication } from '@nestjs/platform-express';
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
 import { exec } from 'child_process';
 import compression = require('compression');
 import cookieParser = require('cookie-parser');
 
 import envConfig from './config.env';
+import { FilterArgs } from './core/common/args/filter.args';
 import { HttpExceptionLogFilter } from './core/common/filters/http-exception-log.filter';
+import { CorePersistenceModel } from './core/common/models/core-persistence.model';
+import { CoreAuthModel } from './core/modules/auth/core-auth.model';
+import { CoreUserModel } from './core/modules/user/core-user.model';
+import { PersistenceModel } from './server/common/models/persistence.model';
+import { Auth } from './server/modules/auth/auth.model';
+import { User } from './server/modules/user/user.model';
 import { ServerModule } from './server/server.module';
 
 /**
@@ -54,6 +62,23 @@ async function bootstrap() {
   // Enable cors to allow requests from other domains
   server.enableCors();
 
+  // Swagger documentation
+  const config = new DocumentBuilder()
+    .setTitle('Nest Server API')
+    .setDescription('API lenne.Tech Nest Server')
+    .setVersion('1.0.0')
+    .addBearerAuth()
+    .build();
+  const documentFactory = () =>
+    SwaggerModule.createDocument(server, config, {
+      autoTagControllers: true,
+      deepScanRoutes: true,
+      extraModels: [CoreUserModel, CoreAuthModel, Auth, User, PersistenceModel, CorePersistenceModel, FilterArgs],
+    });
+  SwaggerModule.setup('swagger', server, documentFactory, {
+    jsonDocumentUrl: '/api-docs-json',
+  });
+
   // Start server on configured port
   await server.listen(envConfig.port, envConfig.hostname);
   console.debug(`Server startet at ${await server.getUrl()}`);

package/src/server/common/models/persistence.model.ts

@@ -1,10 +1,10 @@
-import { Field, ObjectType } from '@nestjs/graphql';
-import { Prop } from '@nestjs/mongoose';
-import { ApiExtraModels, ApiProperty } from '@nestjs/swagger';
+import { ObjectType } from '@nestjs/graphql';
+import { ApiExtraModels } from '@nestjs/swagger';
 import { Types } from 'mongoose';
 import mongoose = require('mongoose');
 
 import { Restricted } from '../../../core/common/decorators/restricted.decorator';
+import { UnifiedField } from '../../../core/common/decorators/unified-field.decorator';
 import { RoleEnum } from '../../../core/common/enums/role.enum';
 import { CorePersistenceModel } from '../../../core/common/models/core-persistence.model';
 import { User } from '../../modules/user/user.model';
@@ -30,13 +30,14 @@ export abstract class PersistenceModel extends CorePersistenceModel {
    *
    * Not set when created by system
    */
-  @ApiProperty({ type: String })
-  @Field(() => User, {
+  @UnifiedField({
     description: 'ID of the user who created the object',
-    nullable: true,
+    isOptional: true,
+    mongoose: { ref: 'User', type: mongoose.Schema.Types.ObjectId },
+    roles: RoleEnum.ADMIN,
+    swaggerApiOptions: { type: String },
+    type: () => User,
   })
-  @Prop({ ref: 'User', type: mongoose.Schema.Types.ObjectId })
-  @Restricted(RoleEnum.ADMIN)
   createdBy?: string | Types.ObjectId = undefined;
 
   /**
@@ -44,13 +45,14 @@ export abstract class PersistenceModel extends CorePersistenceModel {
    *
    * Not set when updated by system
    */
-  @ApiProperty({ type: User })
-  @Field(() => User, {
+  @UnifiedField({
     description: 'ID of the user who updated the object',
-    nullable: true,
+    isOptional: true,
+    mongoose: { ref: 'User', type: mongoose.Schema.Types.ObjectId },
+    roles: RoleEnum.ADMIN,
+    swaggerApiOptions: { type: User },
+    type: () => User,
   })
-  @Prop({ ref: 'User', type: mongoose.Schema.Types.ObjectId })
-  @Restricted(RoleEnum.ADMIN)
   updatedBy?: string | Types.ObjectId = undefined;
 
   // ===================================================================================================================

package/src/server/modules/auth/auth.model.ts

@@ -1,6 +1,7 @@
-import { Field, ObjectType } from '@nestjs/graphql';
+import { ObjectType } from '@nestjs/graphql';
 
 import { Restricted } from '../../../core/common/decorators/restricted.decorator';
+import { UnifiedField } from '../../../core/common/decorators/unified-field.decorator';
 import { RoleEnum } from '../../../core/common/enums/role.enum';
 import { mapClasses } from '../../../core/common/helpers/model.helper';
 import { CoreAuthModel } from '../../../core/modules/auth/core-auth.model';
@@ -19,8 +20,11 @@ export class Auth extends CoreAuthModel {
   /**
    * Signed-in user
    */
-  @Field(() => User, { description: 'User who signed in' })
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'User who signed in',
+    roles: RoleEnum.S_EVERYONE,
+    type: () => User,
+  })
   override user: User = undefined;
 
   // ===================================================================================================================

package/src/server/modules/file/file.controller.ts

@@ -11,13 +11,17 @@ import {
   UseInterceptors,
 } from '@nestjs/common';
 import { FileInterceptor } from '@nestjs/platform-express';
+import { Response } from 'express';
+import { Readable } from 'stream';
 
 import { Roles } from '../../../core/common/decorators/roles.decorator';
 import { RoleEnum } from '../../../core/common/enums/role.enum';
+import { CoreFileInfo } from '../../../core/modules/file/core-file-info.model';
+import { FileUpload } from '../../../core/modules/file/interfaces/file-upload.interface';
 import { FileService } from './file.service';
 
 /**
- * File controller for
+ * File controller
  */
 @Controller('files')
 @Roles(RoleEnum.ADMIN)
@@ -28,13 +32,26 @@ export class FileController {
   constructor(private readonly fileService: FileService) {}
 
   /**
-   * Upload file
+   * Upload file via HTTP
    */
   @Post('upload')
   @Roles(RoleEnum.ADMIN)
   @UseInterceptors(FileInterceptor('file'))
-  uploadFile(@UploadedFile() file: Express.Multer.File): any {
-    return file;
+  async uploadFile(@UploadedFile() file: Express.Multer.File): Promise<any> {
+    if (!file) {
+      throw new BadRequestException('No file provided');
+    }
+
+    // Convert Multer file to FileUpload interface
+    const fileUpload: FileUpload = {
+      capacitor: null, // Not used when creating from buffer
+      createReadStream: () => Readable.from(file.buffer),
+      filename: file.originalname,
+      mimetype: file.mimetype,
+    };
+
+    // Save to GridFS using FileService
+    return await this.fileService.createFile(fileUpload);
   }
 
   /**
@@ -42,23 +59,24 @@ export class FileController {
    */
   @Get(':id')
   @Roles(RoleEnum.ADMIN)
-  async getFile(@Param('id') id: string, @Res() res) {
+  async getFile(@Param('id') id: string, @Res() res: Response) {
     if (!id) {
       throw new BadRequestException('Missing ID');
     }
 
-    let file;
+    let file: CoreFileInfo | null;
     try {
       file = await this.fileService.getFileInfo(id);
     } catch (e) {
       console.error(e);
+      file = null;
     }
 
     if (!file) {
       throw new NotFoundException('File not found');
     }
     const filestream = await this.fileService.getFileStream(id);
-    res.header('Content-Type', file.contentType);
+    res.header('Content-Type', file.contentType || 'application/octet-stream');
     res.header('Content-Disposition', `attachment; filename=${file.filename}`);
     res.header('Cache-Control', 'max-age=31536000');
     return filestream.pipe(res);

package/src/server/modules/file/file.resolver.ts

@@ -64,8 +64,7 @@ export class FileResolver {
     // Save files in filesystem
     const promises: Promise<any>[] = [];
     for (const file of files) {
-      // eslint-disable-next-line unused-imports/no-unused-vars
-      const { createReadStream, encoding, filename, mimetype } = await file;
+      const { createReadStream, filename } = await file;
       await fs.promises.mkdir('./uploads', { recursive: true });
       promises.push(
         new Promise((resolve, reject) =>

package/src/server/modules/file/multer-config.service.ts

@@ -1,31 +1,16 @@
-import { GridFsStorage } from '@lenne.tech/multer-gridfs-storage';
 import { Injectable } from '@nestjs/common';
 import { MulterModuleOptions, MulterOptionsFactory } from '@nestjs/platform-express';
+import { memoryStorage } from 'multer';
 
-import envConfig from '../../../config.env';
-
+/**
+ * Multer configuration service using MemoryStorage
+ * Files are stored in memory as Buffer objects and then manually saved to GridFS
+ */
 @Injectable()
 export class GridFsMulterConfigService implements MulterOptionsFactory {
-  gridFsStorage: any;
-
-  constructor() {
-    this.gridFsStorage = new GridFsStorage({
-      file: (req, file) => {
-        return new Promise((resolve) => {
-          const filename = file.originalname.trim();
-          const fileInfo = {
-            filename,
-          };
-          resolve(fileInfo);
-        });
-      },
-      url: envConfig.mongoose.uri,
-    });
-  }
-
   createMulterOptions(): MulterModuleOptions {
     return {
-      storage: this.gridFsStorage,
+      storage: memoryStorage(),
     };
   }
 }

package/src/server/modules/user/user.controller.ts

@@ -0,0 +1,242 @@
+import { Body, Controller, Delete, Get, Param, Patch, Post, Query, UseGuards } from '@nestjs/common';
+import {
+  ApiBearerAuth,
+  ApiBody,
+  ApiCreatedResponse,
+  ApiOkResponse,
+  ApiOperation,
+  ApiParam,
+  ApiQuery,
+  ApiTags,
+} from '@nestjs/swagger';
+
+import { ApiCommonErrorResponses } from '../../../core/common/decorators/common-error.decorator';
+import { CurrentUser } from '../../../core/common/decorators/current-user.decorator';
+import { Roles } from '../../../core/common/decorators/roles.decorator';
+import { RoleEnum } from '../../../core/common/enums/role.enum';
+import { ServiceOptions } from '../../../core/common/interfaces/service-options.interface';
+import { AuthGuardStrategy } from '../../../core/modules/auth/auth-guard-strategy.enum';
+import { AuthGuard } from '../../../core/modules/auth/guards/auth.guard';
+import { UserCreateInput } from './inputs/user-create.input';
+import { UserInput } from './inputs/user.input';
+import { FindAndCountUsersResult } from './outputs/find-and-count-users-result.output';
+import { User } from './user.model';
+import { UserService } from './user.service';
+
+/**
+ * Controller to handle user REST API endpoints
+ */
+@ApiCommonErrorResponses()
+@ApiTags('users')
+@Controller('users')
+@Roles(RoleEnum.ADMIN)
+export class UserController {
+  /**
+   * Import services
+   */
+  constructor(protected readonly userService: UserService) {}
+
+  // ===========================================================================
+  // GET Endpoints (Queries)
+  // ===========================================================================
+
+  /**
+   * Get users (via filter)
+   */
+  @ApiBearerAuth()
+  @ApiOkResponse({ description: 'Users found successfully', type: [User] })
+  @ApiOperation({ description: 'Find users (via filter)', summary: 'Get all users' })
+  @Get()
+  @Roles(RoleEnum.ADMIN)
+  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
+  async findUsers(@CurrentUser() currentUser: User): Promise<User[]> {
+    const serviceOptions: ServiceOptions = {
+      currentUser,
+    };
+    return await this.userService.find({}, serviceOptions);
+  }
+
+  /**
+   * Get users and total count (via filter)
+   */
+  @ApiBearerAuth()
+  @ApiOkResponse({ description: 'Users and count found successfully', type: FindAndCountUsersResult })
+  @ApiOperation({
+    description: 'Find users and total count (via filter)',
+    summary: 'Get users with count',
+  })
+  @Get('count')
+  @Roles(RoleEnum.ADMIN)
+  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
+  async findAndCountUsers(@CurrentUser() currentUser: User): Promise<FindAndCountUsersResult> {
+    const serviceOptions: ServiceOptions = {
+      currentUser,
+    };
+    return await this.userService.findAndCount({}, serviceOptions);
+  }
+
+  /**
+   * Get verified state of user with token
+   */
+  @ApiOkResponse({ description: 'Verified state retrieved successfully', type: Boolean })
+  @ApiOperation({
+    description: 'Get verified state of user with token',
+    summary: 'Check if user is verified',
+  })
+  @ApiQuery({ description: 'Verification token', name: 'token', type: String })
+  @Get('verified-state')
+  @Roles(RoleEnum.S_EVERYONE)
+  async getVerifiedState(@Query('token') token: string): Promise<boolean> {
+    return await this.userService.getVerifiedState(token);
+  }
+
+  /**
+   * Get user via ID
+   */
+  @ApiBearerAuth()
+  @ApiOkResponse({ description: 'User found successfully', type: User })
+  @ApiOperation({ description: 'Get user with specified ID', summary: 'Get user by ID' })
+  @ApiParam({ description: 'User ID', name: 'id', type: String })
+  @Get(':id')
+  @Roles(RoleEnum.S_USER)
+  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
+  async getUser(@CurrentUser() currentUser: User, @Param('id') id: string): Promise<User> {
+    const serviceOptions: ServiceOptions = {
+      currentUser,
+      roles: [RoleEnum.ADMIN, RoleEnum.S_CREATOR, RoleEnum.S_SELF],
+    };
+    return await this.userService.get(id, serviceOptions);
+  }
+
+  // ===========================================================================
+  // POST Endpoints (Mutations)
+  // ===========================================================================
+
+  /**
+   * Create new user
+   */
+  @ApiBearerAuth()
+  @ApiBody({ type: UserCreateInput })
+  @ApiCreatedResponse({ description: 'User created successfully', type: User })
+  @ApiOperation({ description: 'Create a new user', summary: 'Create user' })
+  @Post()
+  @Roles(RoleEnum.ADMIN)
+  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
+  async createUser(@CurrentUser() currentUser: User, @Body() input: UserCreateInput): Promise<User> {
+    const serviceOptions: ServiceOptions = {
+      currentUser,
+      inputType: UserCreateInput,
+    };
+    return await this.userService.create(input, serviceOptions);
+  }
+
+  /**
+   * Request new password for user with email
+   */
+  @ApiBody({
+    description: 'User email',
+    schema: {
+      properties: {
+        email: { type: 'string' },
+      },
+      type: 'object',
+    },
+  })
+  @ApiOkResponse({ description: 'Password reset email sent successfully', type: Boolean })
+  @ApiOperation({
+    description: 'Request new password for user with email',
+    summary: 'Request password reset',
+  })
+  @Post('password/reset-request')
+  @Roles(RoleEnum.S_EVERYONE)
+  async requestPasswordResetMail(@Body('email') email: string): Promise<boolean> {
+    return !!(await this.userService.sendPasswordResetMail(email));
+  }
+
+  /**
+   * Set new password for user with token
+   */
+  @ApiBody({
+    description: 'Password reset data',
+    schema: {
+      properties: {
+        password: { type: 'string' },
+        token: { type: 'string' },
+      },
+      type: 'object',
+    },
+  })
+  @ApiOkResponse({ description: 'Password reset successfully', type: Boolean })
+  @ApiOperation({ description: 'Set new password for user with token', summary: 'Reset password' })
+  @Post('password/reset')
+  @Roles(RoleEnum.S_EVERYONE)
+  async resetPassword(@Body('token') token: string, @Body('password') password: string): Promise<boolean> {
+    return !!(await this.userService.resetPassword(token, password));
+  }
+
+  /**
+   * Verify user with email
+   */
+  @ApiBody({
+    description: 'Verification token',
+    schema: {
+      properties: {
+        token: { type: 'string' },
+      },
+      type: 'object',
+    },
+  })
+  @ApiOkResponse({ description: 'User verified successfully', type: Boolean })
+  @ApiOperation({ description: 'Verify user with email', summary: 'Verify user' })
+  @Post('verify')
+  @Roles(RoleEnum.S_EVERYONE)
+  async verifyUser(@Body('token') token: string): Promise<boolean> {
+    return !!(await this.userService.verify(token));
+  }
+
+  // ===========================================================================
+  // PATCH Endpoints (Updates)
+  // ===========================================================================
+
+  /**
+   * Update existing user
+   */
+  @ApiBearerAuth()
+  @ApiBody({ type: UserInput })
+  @ApiOkResponse({ description: 'User updated successfully', type: User })
+  @ApiOperation({ description: 'Update existing user', summary: 'Update user' })
+  @ApiParam({ description: 'User ID', name: 'id', type: String })
+  @Patch(':id')
+  @Roles(RoleEnum.S_USER)
+  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
+  async updateUser(@CurrentUser() currentUser: User, @Param('id') id: string, @Body() input: UserInput): Promise<User> {
+    const serviceOptions: ServiceOptions = {
+      currentUser,
+      inputType: UserInput,
+      roles: [RoleEnum.ADMIN, RoleEnum.S_CREATOR, RoleEnum.S_SELF],
+    };
+    return await this.userService.update(id, input, serviceOptions);
+  }
+
+  // ===========================================================================
+  // DELETE Endpoints
+  // ===========================================================================
+
+  /**
+   * Delete existing user
+   */
+  @ApiBearerAuth()
+  @ApiOkResponse({ description: 'User deleted successfully', type: User })
+  @ApiOperation({ description: 'Delete existing user', summary: 'Delete user' })
+  @ApiParam({ description: 'User ID', name: 'id', type: String })
+  @Delete(':id')
+  @Roles(RoleEnum.S_USER)
+  @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
+  async deleteUser(@CurrentUser() currentUser: User, @Param('id') id: string): Promise<User> {
+    const serviceOptions: ServiceOptions = {
+      currentUser,
+      roles: [RoleEnum.ADMIN, RoleEnum.S_CREATOR, RoleEnum.S_SELF],
+    };
+    return await this.userService.delete(id, serviceOptions);
+  }
+}

package/src/server/modules/user/user.model.ts

@@ -1,10 +1,11 @@
-import { Field, ObjectType } from '@nestjs/graphql';
+import { ObjectType } from '@nestjs/graphql';
 import { Schema as MongooseSchema, Prop, SchemaFactory } from '@nestjs/mongoose';
-import { IsEmail, IsOptional } from 'class-validator';
+import { IsEmail } from 'class-validator';
 import { Document, Schema } from 'mongoose';
 
 import { Restricted } from '../../../core/common/decorators/restricted.decorator';
 import { Translatable } from '../../../core/common/decorators/translatable.decorator';
+import { UnifiedField } from '../../../core/common/decorators/unified-field.decorator';
 import { RoleEnum } from '../../../core/common/enums/role.enum';
 import { CoreUserModel } from '../../../core/modules/user/core-user.model';
 import { PersistenceModel } from '../../common/models/persistence.model';
@@ -25,9 +26,12 @@ export class User extends CoreUserModel implements PersistenceModel {
   /**
    * URL to avatar file of the user
    */
-  @Field({ description: 'URL to avatar file of the user', nullable: true })
-  @Prop()
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'URL to avatar file of the user',
+    isOptional: true,
+    mongoose: true,
+    roles: RoleEnum.S_EVERYONE,
+  })
   avatar: string = undefined;
 
   /**
@@ -35,39 +39,47 @@ export class User extends CoreUserModel implements PersistenceModel {
    *
    * Not set when created by system
    */
-  @Field(() => String, {
+  @UnifiedField({
     description: 'ID of the user who created the object',
-    nullable: true,
+    isOptional: true,
+    mongoose: { ref: 'User', type: Schema.Types.ObjectId },
+    roles: RoleEnum.S_EVERYONE,
+    type: () => String,
   })
-  @Prop({ ref: 'User', type: Schema.Types.ObjectId })
-  @Restricted(RoleEnum.S_EVERYONE)
   createdBy: string = undefined;
 
   /**
    * E-Mail address of the user
    */
-  @Field({ description: 'Email of the user', nullable: true })
-  @IsEmail()
-  @Prop({ lowercase: true, trim: true, unique: true })
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Email of the user',
+    isOptional: true,
+    mongoose: { lowercase: true, trim: true, unique: true },
+    roles: RoleEnum.S_EVERYONE,
+    validator: () => [IsEmail()],
+  })
   override email: string = undefined;
 
   /**
    * Roles of the user
    */
-  @Field(() => [String], { description: 'Roles of the user', nullable: true })
-  @IsOptional()
-  @Prop([String])
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Roles of the user',
+    isArray: true,
+    isOptional: true,
+    mongoose: [String],
+    roles: RoleEnum.S_EVERYONE,
+    type: () => String,
+  })
   override roles: string[] = undefined;
 
-  @Field(() => String, {
+  @Translatable()
+  @UnifiedField({
     description: 'Job title of user',
-    nullable: true,
+    isOptional: true,
+    mongoose: true,
+    roles: RoleEnum.S_EVERYONE,
   })
-  @Prop()
-  @Restricted(RoleEnum.S_EVERYONE)
-  @Translatable()
   jobTitle?: string = undefined;
 
   /**
@@ -75,12 +87,13 @@ export class User extends CoreUserModel implements PersistenceModel {
    *
    * Not set when updated by system
    */
-  @Field(() => String, {
+  @UnifiedField({
     description: 'ID of the user who last updated the object',
-    nullable: true,
+    isOptional: true,
+    mongoose: { ref: 'User', type: Schema.Types.ObjectId },
+    roles: RoleEnum.S_USER,
+    type: () => String,
   })
-  @Prop({ ref: 'User', type: Schema.Types.ObjectId })
-  @Restricted(RoleEnum.S_USER)
   updatedBy: string = undefined;
 
   @Prop({ default: {}, type: Schema.Types.Mixed })

package/src/server/modules/user/user.module.ts

@@ -4,6 +4,7 @@ import { PubSub } from 'graphql-subscriptions';
 
 import { ConfigService } from '../../../core/common/services/config.service';
 import { AvatarController } from './avatar.controller';
+import { UserController } from './user.controller';
 import { User, UserSchema } from './user.model';
 import { UserResolver } from './user.resolver';
 import { UserService } from './user.service';
@@ -12,7 +13,7 @@ import { UserService } from './user.service';
  * User module
  */
 @Module({
-  controllers: [AvatarController],
+  controllers: [AvatarController, UserController],
   exports: [MongooseModule, UserResolver, UserService, 'USER_CLASS'],
   imports: [MongooseModule.forFeature([{ name: User.name, schema: UserSchema }])],
   providers: [

package/src/types/graphql-upload.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Type definitions for graphql-upload
+ * graphql-upload uses deep imports, so we declare types for the specific modules
+ */
+
+declare module 'graphql-upload/graphqlUploadExpress.js' {
+  import { RequestHandler } from 'express';
+
+  interface GraphQLUploadOptions {
+    maxFiles?: number;
+    maxFileSize?: number;
+  }
+
+  function graphqlUploadExpress(options?: GraphQLUploadOptions): RequestHandler;
+
+  export = graphqlUploadExpress;
+}
+
+declare module 'graphql-upload/GraphQLUpload.js' {
+  import { GraphQLScalarType } from 'graphql';
+
+  const GraphQLUpload: GraphQLScalarType;
+
+  export = GraphQLUpload;
+}