@mshima/generator-jhipster-nodejs 0.0.0-stage → 0.0.2

package/generators/node-server/templates/server/src/users/authority.controller.ts.ejs

@@ -0,0 +1,85 @@
+import { Body, Controller, Delete, Get, NotFoundException, Param, Post as PostMethod, Req, UseGuards } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { <% if (authenticationTypeJwt) { %>ApiBearerAuth<% } else { %>ApiSecurity<% } %>, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { Repository } from 'typeorm';
+
+import { HeaderUtil } from '../common/header-util.ts';
+import { Request } from '../common/request.ts';
+import { Authority } from './authority.entity.ts';
+import { AuthGuard, Roles, RolesGuard } from '../auth/index.ts';
+import { AuthorityDTO } from './dto/authority.dto.ts';
+
+import { BadRequestAlertException } from '../common/errors/problem.exception.ts';
+
+const ENTITY_NAME = '<%= nodejsAuthorityAlertName %>';
+
+/**
+ * The authorities, like the AuthorityResource of JHipster Spring Boot: for the administrators, the profiles the user
+ * management assigns, and the authority pages of the client.
+ */
+@Controller('api/authorities')
+@UseGuards(AuthGuard, RolesGuard)
+@Roles(<%- authority.nodejsWriteRoles %>)
+<%_ if (authenticationTypeJwt) { _%>
+@ApiBearerAuth()
+<%_ } else { _%>
+@ApiSecurity({})
+<%_ } _%>
+@ApiTags('authority-resource')
+export class AuthorityController {
+  constructor(
+    @InjectRepository(Authority) private readonly authorityRepository: Repository<Authority>,
+    private readonly headerUtil: HeaderUtil,
+  ) {}
+
+  @Get()
+<%_ if (authority.nodejsReadOnlyRoles) { _%>
+  // The roles of @EntityReadAuthority read the authorities too, like JHipster Spring Boot.
+  @Roles(<%- authority.nodejsReadRoles %>)
+<%_ } _%>
+  @ApiOperation({ summary: 'Get all the authorities' })
+  @ApiResponse({ status: 200, type: AuthorityDTO, isArray: true })
+  async getAll(): Promise<AuthorityDTO[]> {
+    const authorities = await this.authorityRepository.find();
+    return authorities.map(({ name }) => ({ name }));
+  }
+
+  @Get('/:name')
+<%_ if (authority.nodejsReadOnlyRoles) { _%>
+  // The roles of @EntityReadAuthority read the authorities too, like JHipster Spring Boot.
+  @Roles(<%- authority.nodejsReadRoles %>)
+<%_ } _%>
+  @ApiOperation({ summary: 'Get an authority' })
+  @ApiResponse({ status: 200, type: AuthorityDTO })
+  @ApiResponse({ status: 404, description: 'No authority of that name.' })
+  async getOne(@Param('name') name: string): Promise<AuthorityDTO> {
+    const authority = await this.authorityRepository.findOne({ where: { name } });
+    if (!authority) {
+      throw new NotFoundException();
+    }
+    return { name: authority.name };
+  }
+
+  @PostMethod()
+  @ApiOperation({ summary: 'Create an authority' })
+  @ApiResponse({ status: 201, type: AuthorityDTO })
+  @ApiResponse({ status: 400, description: 'The authority exists already.' })
+  async create(@Req() req: Request, @Body() authorityDTO: AuthorityDTO): Promise<AuthorityDTO> {
+    // Like JHipster Spring Boot, the name is the id of an authority: an existing one is not a new one.
+    if (await this.authorityRepository.findOne({ where: { name: authorityDTO.name } })) {
+      throw new BadRequestAlertException('A new authority cannot already have an ID', ENTITY_NAME, 'idexists');
+    }
+    await this.authorityRepository.save(this.authorityRepository.create({ name: authorityDTO.name }));
+    this.headerUtil.addEntityCreatedHeaders(req.res, ENTITY_NAME, authorityDTO.name);
+    req.res.location(`/api/authorities/${encodeURIComponent(authorityDTO.name)}`);
+    return { name: authorityDTO.name };
+  }
+
+  @Delete('/:name')
+  @ApiOperation({ summary: 'Delete an authority' })
+  @ApiResponse({ status: 204, description: 'The authority has been deleted.' })
+  async delete(@Req() req: Request, @Param('name') name: string): Promise<void> {
+    this.headerUtil.addEntityDeletedHeaders(req.res, ENTITY_NAME, name);
+    await this.authorityRepository.delete({ name });
+  }
+}

package/generators/node-server/templates/server/src/users/authority.entity.ts.ejs

@@ -0,0 +1,22 @@
+import { Entity, <%_ if (databaseType === 'mongodb') { _%> ObjectIdColumn, <%_ } _%><%_ if (databaseType === 'mongodb') { _%> Column <%_ } else { _%> PrimaryColumn <%_ } _%> } from 'typeorm';
+import { ApiProperty } from '@nestjs/swagger';
+<%_ if (databaseType === 'mongodb') { _%>
+import { BaseEntity } from '../common/database/base.entity.ts';
+<%_ } _%>
+
+@Entity('<%- jhiTablePrefix %>_authority')
+<%_ if (databaseTypeMongodb) { _%>
+export class Authority extends BaseEntity {
+    @ObjectIdColumn({ name: '_id' })
+    id?: string;
+<%_ } else { _%>
+export class Authority {
+<%_ } _%>
+  @ApiProperty({ example: 'ROLE_USER', description: 'User role' })
+  <%_ if (databaseTypeMongodb) { _%>
+  @Column({ unique: true })
+  <%_ } else { _%>
+  @PrimaryColumn()
+  <%_ } _%>
+  name!: string;
+}

package/generators/node-server/templates/server/src/users/dto/authority.dto.ts.ejs

@@ -0,0 +1,10 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNotEmpty, MaxLength } from 'class-validator';
+
+/** An authority, like the Authority of JHipster Spring Boot: its name, like ROLE_USER. */
+export class AuthorityDTO {
+  @ApiProperty({ example: 'ROLE_USER', description: 'The name of the authority' })
+  @IsNotEmpty()
+  @MaxLength(50)
+  name!: string;
+}

package/generators/node-server/templates/server/src/users/dto/user.dto.ts.ejs

@@ -0,0 +1,116 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Allow, IsBoolean, IsEmail, IsNotEmpty, IsOptional, IsString, Length, Matches, MaxLength } from 'class-validator';
+<%_ if (databaseTypeMongodb) { _%>
+import { Transform } from 'class-transformer';
+<%_ } _%>
+import { Exclude } from 'class-transformer';
+import { BaseDTO } from '../../common/dto/base.dto.ts';
+
+/** The pattern of a login, the one of the clients of JHipster (the LOGIN_REGEX of JHipster Spring Boot). */
+export const LOGIN_PATTERN = /^[a-zA-Z0-9!$&*+=?^_`{|}~.-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$|^[_.@A-Za-z0-9-]+$/;
+export const PASSWORD_MIN_LENGTH = 4;
+export const PASSWORD_MAX_LENGTH = 100;
+
+/**
+ * A user, with the constraints of the AdminUserDTO of JHipster Spring Boot.
+ */
+export class <%= userLoginVmClass %> extends BaseDTO {
+<%_ if (user) { _%>
+<%_ if (databaseTypeMongodb) { _%>
+  @Transform(({ value }) => value?.toHexString ? value?.toHexString() : value, {toPlainOnly: true})
+<%_ } _%>
+  @Allow()
+  <%= user.primaryKey.name %>?: <%= user.primaryKey.tsType %>;
+<%_ } else { _%>
+  @Allow()
+  id?: string;
+<%_ } _%>
+
+  @ApiProperty({ uniqueItems: true, example: 'myuser', description: 'User login' })
+  @IsString()
+  @IsNotEmpty()
+  @Length(1, 50)
+  @Matches(LOGIN_PATTERN)
+  login!: string;
+
+  @ApiProperty({ example: 'MyUser', description: 'User first name', required: false })
+  @IsOptional()
+  @IsString()
+  @MaxLength(50)
+  firstName?: string;
+
+  @ApiProperty({ example: 'MyUser', description: 'User last name', required: false })
+  @IsOptional()
+  @IsString()
+  @MaxLength(50)
+  lastName?: string;
+
+  @ApiProperty({ example: 'myuser@localhost', description: 'User email' })
+  // A domain without a top level domain too, like user@localhost, as the @Email of JHipster Spring Boot.
+  @IsEmail({ require_tld: false })
+  @Length(5, 254)
+  email!: string;
+
+  @ApiProperty({ example: 'true', description: 'User activation', required: false })
+  @IsOptional()
+  @IsBoolean()
+  activated?: boolean;
+
+  @ApiProperty({ example: 'en', description: 'User language', required: false })
+  @IsOptional()
+  @IsString()
+  @Length(2, 10)
+  langKey?: string;
+
+  @ApiProperty({
+    isArray: true,
+    enum: ['ROLE_USER', 'ROLE_ADMIN', 'ROLE_ANONYMOUS'],
+    description: 'Array of permissions',
+    required: false
+  })
+  @Allow()
+  authorities?: any[];
+
+  // Never in the responses.
+  @Exclude({ toPlainOnly: true })
+  @ApiProperty({ example: 'myuser', description: 'User password' })
+  @Allow()
+  password<%- generateUserManagement ? '!' : '?' %>: string;
+
+  @ApiProperty({ example: 'http://my-image-url', description: 'Image url', required: false })
+  @IsOptional()
+  @IsString()
+  @MaxLength(256)
+  imageUrl?: string;
+
+  // The keys the mails send to the user, never in the responses, like the DTOs of JHipster Spring Boot.
+  @Exclude()
+  activationKey?: string;
+
+  @Exclude()
+  resetKey?: string;
+
+  @Exclude()
+  resetDate?: Date;
+}
+
+/** A user registering, with a password, like the ManagedUserVM of JHipster Spring Boot. */
+export class Managed<%= userLoginVmClass %> extends <%= userLoginVmClass %> {
+  @Exclude({ toPlainOnly: true })
+  @ApiProperty({ example: 'myuser', description: 'User password', minLength: PASSWORD_MIN_LENGTH, maxLength: PASSWORD_MAX_LENGTH })
+  @IsString()
+  @Length(PASSWORD_MIN_LENGTH, PASSWORD_MAX_LENGTH)
+  // Initialized like the redeclaration of a property must be (useDefineForClassFields), the body sets it.
+  override password = '';
+}
+<%_ if (user) { _%>
+
+/** A user of the public user list, like the UserDTO of JHipster Spring Boot: its id and login only. */
+export class PublicUserDTO {
+  @ApiProperty({ description: 'User id' })
+  id!: <%= user.primaryKey.tsType %>;
+
+  @ApiProperty({ example: 'myuser', description: 'User login' })
+  login!: string;
+}
+<%_ } _%>

package/generators/node-server/templates/server/src/users/public.user.controller.ts.ejs

@@ -0,0 +1,51 @@
+import { Controller, ClassSerializerInterceptor, Get, Logger, Req, UseGuards, UseInterceptors } from '@nestjs/common';
+import { PageRequest, Page } from '../common/database/pagination.entity.ts';
+import { PublicUserDTO } from './dto/user.dto.ts';
+import { AuthGuard } from '../auth/index.ts';
+import { Request } from '../common/request.ts';
+import { HeaderUtil } from '../common/header-util.ts';
+import { ApiTags, ApiResponse, ApiOperation } from '@nestjs/swagger';
+import { UserService } from './user.service.ts';
+
+// The properties the public user list can be sorted on, like the PublicUserResource of JHipster Spring Boot.
+const ALLOWED_ORDERED_PROPERTIES = ['<%- user.primaryKey.name %>', 'login', 'firstName', 'lastName', 'email', 'activated', 'langKey'];
+
+@Controller('api')
+@UseInterceptors(ClassSerializerInterceptor)
+@ApiTags('public-user-controller')
+export class PublicUserController {
+
+  logger = new Logger('PublicUserController');
+
+  constructor(
+    private readonly userService: UserService,
+    private readonly headerUtil: HeaderUtil,
+  ) {}
+
+  /** Like the PublicUserResource of JHipster Spring Boot: the activated users, by their id and login, for authenticated users. */
+  @Get('/users')
+  @UseGuards(AuthGuard)
+  @ApiOperation({ summary: 'Get the list of the activated users, by their id and login' })
+  @ApiResponse({
+      status: 200,
+      description: 'List the activated users',
+      type: PublicUserDTO,
+      isArray: true,
+  })
+  async getAllPublicUsers(@Req() req: Request): Promise<PublicUserDTO[]> {
+      const pageRequest: PageRequest = new PageRequest(
+        req.query.page,
+        req.query.size,
+        req.query.sort ?? '<%- user.primaryKey.name %>,ASC',
+        property => ALLOWED_ORDERED_PROPERTIES.includes(property),
+      );
+      const [results, count] = await this.userService.findPublicUsers({
+          skip: +pageRequest.page * pageRequest.size,
+          take: +pageRequest.size,
+          order: pageRequest.asOrder(),
+      });
+      this.headerUtil.addPaginationHeaders(req.res, new Page(results, count, pageRequest));
+      return results;
+  }
+
+}

package/generators/node-server/templates/server/src/users/user.controller.ts.ejs

@@ -0,0 +1,191 @@
+import { Body, Controller, NotFoundException, Delete, Get, Logger, Param, Post, Put, UseGuards, Req, UseInterceptors, ClassSerializerInterceptor } from '@nestjs/common';
+import { AuthGuard,  Roles, RolesGuard, RoleType } from '../auth/index.ts';
+import { PageRequest, Page } from '../common/database/pagination.entity.ts';
+import { <%= user.dtoClass%> } from './dto/user.dto.ts';
+import { HeaderUtil } from '../common/header-util.ts';
+import { Request } from '../common/request.ts';
+import {<%_ if (authenticationTypeJwt) { _%> ApiBearerAuth, <%_ } else { _%> ApiSecurity, <%_ } _%> ApiTags, ApiResponse, ApiOperation } from '@nestjs/swagger';
+import { UserService } from './user.service.ts';
+import { MailService } from '../mail/mail.service.ts';
+import { randomBytes } from 'crypto';
+import { BadRequestAlertException, EmailAlreadyUsedException, LoginAlreadyUsedException } from '../common/errors/problem.exception.ts';
+import { isSortableProperty } from '../common/sortable-properties.ts';
+
+// The columns of a user no list can be sorted on: its password, its activation and reset keys and the date of its reset.
+const UNSORTABLE_PROPERTIES = ['password', 'activationKey', 'resetKey', 'resetDate'];
+
+@Controller('api/admin/users')
+@UseGuards(AuthGuard, RolesGuard)
+@UseInterceptors(ClassSerializerInterceptor)
+<%_ if (authenticationType === 'jwt') { _%>
+@ApiBearerAuth()
+<%_ } else { _%>
+@ApiSecurity({})
+<%_ } _%>
+@ApiTags('user-resource')
+export class UserController {
+  logger = new Logger('UserController');
+
+  constructor(
+    private readonly userService: UserService,
+    private readonly mailService: MailService,
+    private readonly headerUtil: HeaderUtil,
+  ) {}
+
+  @Get('/')
+  @Roles(RoleType.ADMIN)
+  @ApiOperation({ summary: 'Get the list of users' })
+  @ApiResponse({
+      status: 200,
+      description: 'List all users',
+      type: <%= user.dtoClass%>,
+      isArray: true,
+  })
+  async getAllUsers(@Req() req: Request): Promise<<%= user.dtoClass%>[]> {
+      const pageRequest: PageRequest = new PageRequest(
+        req.query.page,
+        req.query.size,
+        req.query.sort ?? '<%- user.primaryKey.name %>,ASC',
+        property => isSortableProperty(this.userService.metadata, property, { unsortable: UNSORTABLE_PROPERTIES }),
+      );
+      const [results, count] = await this.userService.findAndCount({
+          skip: +pageRequest.page * pageRequest.size,
+          take: +pageRequest.size,
+          order: pageRequest.asOrder(),
+      });
+      this.headerUtil.addPaginationHeaders(req.res, new Page(results, count, pageRequest));
+      return results;
+  }
+
+  @Post('/')
+  @Roles(RoleType.ADMIN)
+  @ApiOperation({ summary: 'Create user' })
+  @ApiResponse({
+      status: 201,
+      description: 'The record has been successfully created.',
+      type: <%= user.dtoClass%>,
+  })
+  @ApiResponse({ status: 403, description: 'Forbidden.' })
+  @ApiResponse({ status: 400, description: 'The user already has an id, or its login or mail is already used.' })
+  async createUser(@Req() req: Request, @Body() userDTO: <%= user.dtoClass%>): Promise<<%= user.dtoClass%>> {
+      if (userDTO.<%= user.primaryKey.name %> !== undefined && userDTO.<%= user.primaryKey.name %> !== null) {
+          // Like JHipster Spring Boot, a new user cannot have an id: it would update an existing one.
+          throw new BadRequestAlertException('A new user cannot already have an ID', 'userManagement', 'idexists');
+      }
+      // Like JHipster Spring Boot, the login and the mail in lower case, each one of a single user.
+      const login = userDTO.login.toLowerCase();
+      const email = userDTO.email.toLowerCase();
+      if (await this.userService.findByFields({ where: { login } })) {
+          throw new LoginAlreadyUsedException();
+      }
+      if (await this.userService.findByFields({ where: { email } })) {
+          throw new EmailAlreadyUsedException();
+      }
+      // The fields of the UserService.createUser of JHipster Spring Boot only (not the password, the keys or the audit of
+      // the body): the user is activated, with a random password and a reset key, the creation mail linking to the page that
+      // sets the password.
+      const created = await this.userService.save(
+        {
+          login,
+          firstName: userDTO.firstName,
+          lastName: userDTO.lastName,
+          email,
+          imageUrl: userDTO.imageUrl,
+          langKey: userDTO.langKey ?? '<%= nativeLanguage %>',
+          authorities: userDTO.authorities,
+          activated: true,
+          password: randomBytes(15).toString('base64url'),
+          resetKey: randomBytes(15).toString('base64url'),
+          resetDate: new Date(),
+        },
+        req.user?.login,
+<%_ if (generateUserManagement) { _%>
+        true,
+<%_ } _%>
+      );
+      void this.mailService.sendCreationEmail(created);
+      this.headerUtil.addUserManagementHeaders(req.res, 'created', created.login);
+      // Like JHipster Spring Boot, the location of the created user, by its login.
+      req.res.location(`/api/admin/users/${encodeURIComponent(created.login)}`);
+      return created;
+  }
+
+  @Put(['/', '/:login'])
+  @Roles(RoleType.ADMIN)
+  @ApiOperation({ summary: 'Update user' })
+  @ApiResponse({
+      status: 200,
+      description: 'The record has been successfully updated.',
+      type: <%= user.dtoClass%>,
+  })
+  @ApiResponse({ status: 400, description: 'The login or the mail is used by another user.' })
+  @ApiResponse({ status: 404, description: 'No user of this id.' })
+  async updateUser(@Req() req: Request, @Body() userDTO: <%= user.dtoClass%>): Promise<<%= user.dtoClass%>> {
+    // Like JHipster Spring Boot, the user of the id of the body, whose login and mail are not the ones of another user.
+    const id = userDTO.<%= user.primaryKey.name %>;
+    const isAnotherUser = (other?: <%= user.dtoClass%>): boolean => other !== undefined && other !== null && String(other.<%= user.primaryKey.name %>) !== String(id);
+    const login = userDTO.login.toLowerCase();
+    const email = userDTO.email.toLowerCase();
+    if (isAnotherUser(await this.userService.findByFields({ where: { email } }))) {
+      throw new EmailAlreadyUsedException();
+    }
+    if (isAnotherUser(await this.userService.findByFields({ where: { login } }))) {
+      throw new LoginAlreadyUsedException();
+    }
+    const existing = id === undefined || id === null ? undefined : await this.userService.findByFields({ where: { <%= user.primaryKey.name %>: id } });
+    if (!existing) {
+      throw new NotFoundException();
+    }
+    // The fields of the UserService.updateUser of JHipster Spring Boot only: the password, the keys and the audit stay.
+    const updated = await this.userService.update(
+      {
+        ...existing,
+        login,
+        firstName: userDTO.firstName,
+        lastName: userDTO.lastName,
+        email,
+        imageUrl: userDTO.imageUrl,
+        activated: userDTO.activated,
+        langKey: userDTO.langKey,
+        authorities: userDTO.authorities,
+      },
+      req.user?.login,
+    );
+    this.headerUtil.addUserManagementHeaders(req.res, 'updated', updated.login);
+    return updated;
+  }
+
+  @Get('/:login')
+  @Roles(RoleType.ADMIN)
+  @ApiOperation({ summary: 'Get user' })
+  @ApiResponse({
+      status: 200,
+      description: 'The found record',
+      type: <%= user.dtoClass%>,
+  })
+  async getUser(@Param('login') loginValue: string): Promise<<%= user.dtoClass%>> {
+      // With its authorities, which the edition page of the client shows and sends back.
+      const user = await this.userService.findByFields({ where: { login: loginValue } });
+      if (!user) {
+        throw new NotFoundException();
+      }
+      return user;
+  }
+
+  @Delete('/:login')
+  @Roles(RoleType.ADMIN)
+  @ApiOperation({ summary: 'Delete user' })
+  @ApiResponse({
+      status: 204,
+      description: 'The record has been successfully deleted.',
+      type: <%= user.dtoClass%>
+  })
+  async deleteUser(@Req() req: Request, @Param('login') loginValue: string): Promise<<%= user.dtoClass%> | undefined> {
+      const userToDelete = await this.userService.find({ where: { login: loginValue } });
+      if (!userToDelete) {
+        throw new NotFoundException();
+      }
+      this.headerUtil.addUserManagementHeaders(req.res, 'deleted', loginValue);
+      return await this.userService.delete(userToDelete);
+  }
+}

package/generators/node-server/templates/server/src/users/user.entity.ts.ejs

@@ -0,0 +1,63 @@
+import { Authority } from './authority.entity.ts';
+import { <%_ if (databaseType === 'mongodb') { _%> ObjectIdColumn <%_ } else { _%> PrimaryGeneratedColumn <%_ } _%>, Entity, Column<%_ if (databaseType !== 'mongodb') { _%>, ManyToMany, JoinTable <%_ } _%> } from 'typeorm';
+import { BaseEntity } from '../common/database/base.entity.ts';
+import { Exclude } from 'class-transformer';
+
+@Entity('<%- jhiTablePrefix %>_user')
+export class <%= user.persistClass %> extends BaseEntity {
+
+<%_ if (databaseTypeMongodb) { _%>
+  @ObjectIdColumn({ name: '_<%- user.primaryKey.name %>' })
+<%_ } else if (databaseTypeSql) { _%>
+  @PrimaryGeneratedColumn(<%- user.primaryKey.typeUUID ? "'uuid'" : '' %>)
+<%_ } _%>
+  <%- user.primaryKey.name %>?: <%- user.primaryKey.tsType %>;
+
+  @Column({ unique: true })
+  login!: string;
+  @Column({ nullable: true })
+  firstName?: string;
+  @Column({ nullable: true })
+  lastName?: string;
+  // Unique, like the ux_user_email constraint of JHipster Spring Boot.
+  @Column({ unique: true })
+  email!: string;
+  @Column({ default: false})
+  activated?: boolean;
+  @Column({default: 'en'})
+  langKey?: string;
+
+  <%_ if (databaseType === 'mongodb') { _%>
+  @Column()
+  authorities?: Authority[];
+  <%_ } else { _%>
+  @ManyToMany(() => Authority)
+  @JoinTable()
+  authorities?: any[];
+  <%_ } _%>
+
+<%_ if (generateUserManagement) { _%>
+  @Column({
+    type: "varchar"
+  })
+  @Exclude()
+  password!: string;
+<%_ } else { _%>
+  // The identity provider authenticates the users: no password of their own, like JHipster Spring Boot with OAuth2.
+  @Column({ type: 'varchar', nullable: true })
+  @Exclude()
+  password?: string;
+<%_ } _%>
+  @Column({ nullable: true })
+  imageUrl?: string;
+  // Never in a response, like the @JsonIgnore keys of JHipster Spring Boot: a user related to an entity is serialized
+  // with this class (the password-reset key would let anyone set its password).
+  @Column({ nullable: true })
+  @Exclude()
+  activationKey?: string;
+  @Column({ nullable: true })
+  @Exclude()
+  resetKey?: string;
+  @Column({ nullable: true })
+  resetDate?: Date;
+}

package/generators/node-server/templates/server/src/users/user.mapper.ts.ejs

@@ -0,0 +1,26 @@
+import { <%= user.persistClass %> } from './user.entity.ts';
+import { <%= user.dtoClass%> } from './dto/user.dto.ts';
+
+/**
+ * An User mapper object.
+ */
+export class UserMapper {
+
+  static fromDTOtoEntity(userDTO: <%= user.dtoClass%>): <%= user.persistClass %>;
+  static fromDTOtoEntity(userDTO: <%= user.dtoClass%> | null | undefined): <%= user.persistClass %> | undefined;
+  static fromDTOtoEntity(userDTO: <%= user.dtoClass%> | null | undefined): <%= user.persistClass %> | undefined {
+    if (!userDTO) {
+      return undefined;
+    }
+    return Object.assign(new <%= user.persistClass %>(), userDTO);
+  }
+
+  static fromEntityToDTO(user: <%= user.persistClass %>): <%= user.dtoClass%>;
+  static fromEntityToDTO(user: <%= user.persistClass %> | null | undefined): <%= user.dtoClass%> | undefined;
+  static fromEntityToDTO(user: <%= user.persistClass %> | null | undefined): <%= user.dtoClass%> | undefined {
+    if (!user) {
+      return undefined;
+    }
+    return Object.assign(new <%= user.dtoClass%>(), user);
+  }
+}

package/generators/node-server/templates/server/src/users/user.module.ts.ejs

@@ -0,0 +1,19 @@
+import { Module } from '@nestjs/common';
+import { User } from './user.entity.ts';
+<%_ if (generateUserManagement) { _%>
+import { UserController } from './user.controller.ts';
+<%_ } _%>
+import { ManagementController } from '../management/management.controller.ts';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { UserService } from './user.service.ts';
+<%_ if (generateUserManagement) { _%>
+import { MailModule } from '../mail/mail.module.ts';
+<%_ } _%>
+
+@Module({
+  imports: [TypeOrmModule.forFeature([User])<% if (generateUserManagement) { %>, MailModule<% } %>],
+  controllers: [<% if (generateUserManagement) { %>UserController, <% } %>ManagementController],
+  providers: [UserService],
+  exports: [UserService<% if (generateUserManagement) { %>, MailModule<% } %>],
+})
+export class UserModule {}