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

package/generators/node-server/templates/server/src/config.ts.ejs

@@ -0,0 +1,255 @@
+import * as yaml from 'js-yaml';
+
+import { type ApplicationConfig, validateConfiguration } from './application-config.ts';
+import * as fs from 'fs';
+import { randomBytes } from 'crypto';
+import { networkInterfaces } from 'os';
+import * as path from 'path';
+import { Logger } from '@nestjs/common';
+
+const logger = new Logger('Config');
+
+export class Config {
+  [key: string]: any;
+
+  // The level of the loggers without a level of their own, like Spring Boot.
+  'logging.level.ROOT' = 'INFO';
+  'server.port' = '<%= serverPort %>';
+  'jhipster.clientApp.name' = '<%= frontendAppName %>';
+<%_ if (serviceDiscoveryEureka) { _%>
+  'jhipster.registry.password' = 'admin';
+<%_ } _%>
+<%_ if (!skipClient) { _%>
+  'jhipster.security.content-security-policy' = "default-src 'self'; frame-src 'self' data:; script-src 'self' 'unsafe-inline' 'unsafe-eval'<%- locals.microfrontend && locals.clientFrameworkAngular ? ' blob:' : '' %> https://storage.googleapis.com; style-src 'self'<%- locals.clientThemeAny ? ' https://fonts.googleapis.com' : '' %> 'unsafe-inline'; img-src 'self' data:; font-src 'self'<%- locals.clientThemeAny ? ' https://fonts.gstatic.com' : '' %> data:";
+<%_ } _%>
+<%_ if (authenticationType === 'jwt') { _%>
+  'jhipster.security.authentication.jwt.base64-secret' = '';
+  'jhipster.security.authentication.jwt.token-validity-in-seconds' = 86400;
+  'jhipster.security.authentication.jwt.token-validity-in-seconds-for-remember-me' = 2592000;
+  'jhipster.security.authentication.jwt.hash-salt-or-rounds' = 10;
+<%_ } else if (authenticationTypeSession) { _%>
+  'jhipster.security.session.secret' = '';
+  '<%= nodejsPasswordRoundsProperty %>' = 10;
+<%_ } else if (authenticationType === 'oauth2') { _%>
+  'jhipster.security.session.secret' = '';
+  'jhipster.security.oauth2.audience' = 'account,api://default';
+  'jhipster.security.oauth2.client.provider.oidc.issuer-uri' = '';
+  'jhipster.security.oauth2.client.registration.oidc.client-id' = '';
+  'jhipster.security.oauth2.client.registration.oidc.client-secret' = '';
+<%_ } _%>
+  // The values of the env and configprops endpoints: never (shown as ******) like Spring Boot, or always.
+  'management.endpoint.env.show-values' = 'never';
+  'management.endpoint.configprops.show-values' = 'never';
+  // CORS is disabled without allowed-origins nor allowed-origin-patterns, like JHipster Spring Boot (application-dev.yml).
+  'jhipster.cors.allowed-origins' = '';
+  'jhipster.cors.allowed-origin-patterns' = '';
+  'jhipster.cors.allowed-methods' = '';
+  'jhipster.cors.allowed-headers' = '';
+  'jhipster.cors.exposed-headers' = '';
+  'jhipster.cors.allow-credentials' = false;
+  'jhipster.cors.max-age' = 1800;
+  'jhipster.mail.base-url' = 'http://127.0.0.1:${server.port}';
+  'jhipster.mail.from' = '<%= baseName %>@localhost';
+<%_ if (generateUserManagement) { _%>
+  'mail.host' = 'localhost';
+  'mail.port' = 25;
+  'mail.username' = '';
+  'mail.password' = '';
+<%_ } _%>
+  'jhipster.swagger.default-include-pattern' = '/api/.*';
+  'jhipster.swagger.title' = '<%= baseName %> API';
+  'jhipster.swagger.description' = '<%= baseName %> API documentation';
+  'jhipster.swagger.version' = '0.0.1';
+  'info.display-ribbon-on-profiles' = 'dev';
+  // The proxies whose X-Forwarded-* headers are trusted, like the server.forward-headers-strategy of Spring Boot: none or native.
+  'server.forward-headers-strategy' = 'none';
+  'server.ssl.enabled' = false;
+  'server.ssl.key-store' = '';
+  'server.ssl.key-store-password' = '';
+  'server.ssl.key-store-type' = 'PKCS12';
+<%_ if (serviceDiscoveryEureka) { _%>
+  'eureka.client.enabled' = true;
+  'eureka.client.fetch-registry' = true;
+  'eureka.client.register-with-eureka' = true;
+  'eureka.client.instance-info-replication-interval-seconds' = 10;
+  'eureka.client.registry-fetch-interval-seconds' = 10;
+  'eureka.instance.appname' = '<%= baseName %>';
+  'eureka.instance.instanceId' = '<%= baseName %>:${random.value}';
+  'eureka.instance.lease-renewal-interval-in-seconds' = 5;
+  'eureka.instance.lease-expiration-duration-in-seconds' = 10;
+  'eureka.instance.prefer-ip-address' = true;
+  'eureka.client.service-url.defaultZone' = 'http://admin:${jhipster.registry.password}@localhost:8761/eureka/';
+  'cloud.config.uri' = 'http://admin:${jhipster.registry.password}@localhost:8761/config';
+  'cloud.config.name' = '<%= baseName %>';
+  'cloud.config.profile' = 'prod';
+  'cloud.config.label' = 'master';
+<%_ } _%>
+<%_ if (serviceDiscoveryConsul) { _%>
+  'cloud.consul.enabled' = false;
+  'cloud.consul.host' = 'localhost';
+  'cloud.consul.port' = 8500;
+  'cloud.consul.discovery.service-name' = '<%= baseName.toLowerCase() %>';
+  'cloud.consul.discovery.instance-id' = '<%= baseName.toLowerCase() %>:${random.value}';
+  'cloud.consul.discovery.health-check-path' = '/management/health';
+  'cloud.consul.discovery.health-check-interval' = '10s';
+  'cloud.consul.discovery.health-check-timeout' = '5s';
+  'cloud.consul.discovery.prefer-ip-address' = false;
+<%_ } _%>
+
+  constructor(properties: Record<string, any>) {
+    this.addAll(properties);
+  }
+
+  public get(key: string): any {
+    return this[key];
+  }
+
+  <%_ if (!skipClient) { _%>
+  public getClientPath(): string {
+    return path.join(import.meta.dirname, '../dist/static');
+  }
+  <%_ } _%>
+  public addAll(properties: Record<string, any>): any {
+    properties = objectToArray(properties);
+    for (const property in properties) {
+      if (properties.hasOwnProperty(property)) {
+        this[property] = properties[property];
+      }
+    }
+    this.applyEnvironment();
+    this.postProcess();
+  }
+
+  /**
+   * Environment variables override the properties, like the relaxed binding of Spring Boot: a property is set by its
+   * name in upper case with the dots as underscores and the dashes removed, like JHIPSTER_MAIL_BASEURL for
+   * jhipster.mail.base-url, or the dashes as underscores, like JHIPSTER_MAIL_BASE_URL.
+   */
+  private applyEnvironment(): void {
+    for (const property of Object.keys(this)) {
+      const name = property.toUpperCase().replace(/\./g, '_');
+      const value = process.env[name.replace(/-/g, '')] ?? process.env[name.replace(/-/g, '_')];
+      if (value !== undefined) {
+        const current = this[property];
+        this[property] = typeof current === 'number' ? Number(value) : typeof current === 'boolean' ? value === 'true' : value;
+      }
+    }
+  }
+
+  public postProcess(): any {
+    // ${random.value} is a random value, like in Spring Boot (the Eureka instance id).
+    const variables = { ...this, ...process.env, 'random.value': randomBytes(16).toString('hex') };
+    for (const property in this) {
+      if (this.hasOwnProperty(property)) {
+        const value = this[property];
+        const processedValue = this.processTemplate(value, variables);
+        this[property] = processedValue;
+      }
+    }
+  }
+
+  private processTemplate(template: any, variables: Record<string, any>): any {
+    // console.log(template);
+    if (typeof template === 'string') {
+      return template.replace(new RegExp('\\${[^{]+}', 'g'), name => variables[name.substring(2, name.length - 1)]);
+    }
+    return template;
+  }
+}
+
+const configFolder = path.join(import.meta.dirname, 'config');
+const yamlConfig: any = yaml.load(fs.readFileSync(path.join(configFolder, 'application.yml'), 'utf8'));
+
+/**
+ * The active profiles, like spring.profiles.active of Spring Boot: the comma separated profiles of BACKEND_ENV (the
+ * default profile without it), each followed by the profiles of its group (profiles.group of application.yml), like dev
+ * that activates secret-samples and api-docs.
+ */
+export const activeProfiles: string[] = expandProfiles((process.env.BACKEND_ENV || 'default').split(','), yamlConfig?.profiles?.group ?? {});
+
+/** Whether one of the profiles is active, like Environment.acceptsProfiles of Spring. */
+export function isProfileActive(...profiles: string[]): boolean {
+  return profiles.some(profile => activeProfiles.includes(profile));
+}
+
+function expandProfiles(profiles: string[], groups: Record<string, string | string[]>, expanded: string[] = []): string[] {
+  for (const profile of profiles.map(name => name.trim()).filter(Boolean)) {
+    if (!expanded.includes(profile)) {
+      expanded.push(profile);
+      const group = groups[profile] ?? [];
+      expandProfiles(typeof group === 'string' ? group.split(',') : group, groups, expanded);
+    }
+  }
+  return expanded;
+}
+
+logger.log(`The following ${activeProfiles.length} profiles are active: ${activeProfiles.join(', ')}`);
+
+// The application-{profile}.yml file of each active profile, when there is one, in the order of the profiles: the last
+// one wins, like in Spring Boot.
+const profileFiles = activeProfiles
+  .map(profile => `application-${profile}.yml`)
+  .filter(fileName => fs.existsSync(path.join(configFolder, fileName)));
+const profileConfigs = profileFiles.map(fileName => objectToArray(yaml.load(fs.readFileSync(path.join(configFolder, fileName), 'utf8'))));
+
+/**
+ * The files of the configuration with their properties, like the property sources of Spring Boot the env endpoint
+ * gives: the highest precedence first (the file of the last active profile), application.yml last.
+ */
+export const configFiles: { name: string; properties: Record<string, any> }[] = [
+  ...profileFiles.map((fileName, index) => ({ name: `Config resource 'config/${fileName}'`, properties: profileConfigs[index] })).reverse(),
+  { name: "Config resource 'config/application.yml'", properties: objectToArray(yamlConfig) },
+];
+
+const config = new Config(Object.assign(objectToArray(yamlConfig), ...profileConfigs, { ipAddress: ipAddress() }));
+
+export { config };
+
+/**
+ * The configuration of the ConfigModule of @nestjs/config: the properties of config (the application*.yml files, the
+ * environment variables and the cloud config), nested by their dotted names, so ConfigService.get('jhipster.swagger.title')
+ * finds them. ConfigModule calls it when the application is created, after the cloud config is loaded by main.ts.
+ * Providers and controllers read the configuration with ConfigService; config stays for the code running before the
+ * application or outside of it (main.ts, tls.ts, the migrations). Validated like the configuration properties of Spring
+ * Boot (application-config.ts): the application does not start with an invalid property.
+ */
+export function configuration(): ApplicationConfig {
+  const nested: Record<string, any> = {};
+  for (const [key, value] of Object.entries(config)) {
+    const names = key.split('.');
+    let target = nested;
+    for (const name of names.slice(0, -1)) {
+      target = target[name] = typeof target[name] === 'object' && target[name] !== null ? target[name] : {};
+    }
+    target[names[names.length - 1]] = value;
+  }
+  return validateConfiguration(nested) as unknown as ApplicationConfig;
+}
+
+function objectToArray(source: any, currentKey?: string, target?: Record<string, any>): Record<string, any> {
+  target = target || {};
+  for (const property in source) {
+    if (source.hasOwnProperty(property)) {
+      const newKey = currentKey ? currentKey + '.' + property : property;
+      const newVal = source[property];
+
+      if (typeof newVal === 'object') {
+        objectToArray(newVal, newKey, target);
+      } else {
+        target[newKey] = newVal;
+      }
+    }
+  }
+  return target;
+}
+
+function ipAddress(): string | null {
+  for (const aliases of Object.values(networkInterfaces())) {
+    for (const alias of aliases ?? []) {
+      if (alias.family === 'IPv4' && alias.address !== '127.0.0.1' && !alias.internal) {
+        return alias.address;
+      }
+    }
+  }
+  return null;
+}

package/generators/node-server/templates/server/src/entities/_entityFileName_/_entityFileName_.controller.ts.ejs

@@ -0,0 +1,178 @@
+<%_
+const pkType = primaryKey.tsType;
+const idPipe = pkType === 'number' ? 'ParseIntPipe' : primaryKey.typeUUID ? 'ParseUUIDPipe' : undefined;
+const idParam = `@Param('id'${idPipe ? `, ${idPipe}` : ''}) id: ${pkType}`;
+_%>
+import { Body, ClassSerializerInterceptor, Controller, Delete, Get, Logger, NotFoundException, Param,<% if (idPipe) { %> <%= idPipe %>,<% } %> Post as PostMethod, Put, UseGuards, Req, UseInterceptors } from '@nestjs/common';
+import { <% if (authenticationTypeJwt) { _%> ApiBearerAuth, <% } else { _%> ApiSecurity, <% } _%> ApiTags, ApiResponse, ApiOperation } from '@nestjs/swagger';
+import { <%= dtoClass %> } from './dto/<%= entityFileName %>.dto.ts';
+import { <%= entityClass %>Service } from './<%= entityFileName %>.service.ts';
+<%_ if (pagination !== 'no') { _%>
+import { PageRequest, Page } from '../../common/database/pagination.entity.ts';
+<%_ } else { _%>
+import { PageRequest } from '../../common/database/pagination.entity.ts';
+<%_ } _%>
+import { AuthGuard, <% if (nodejsReadRoles) { %>Roles, <% } %>RolesGuard } from '../../auth/index.ts';
+import { HeaderUtil } from '../../common/header-util.ts';
+import { isSortableProperty } from '../../common/sortable-properties.ts';
+import { Request } from '../../common/request.ts';
+
+import { BadRequestAlertException } from '../../common/errors/problem.exception.ts';
+
+const ENTITY_NAME = '<%= entityAlertName %>';
+<%_
+const sortLabels = relationships
+  .filter(relationship => relationship.ownerSide && !relationship.collection && relationship.otherEntityField)
+  .map(relationship => `${relationship.propertyName}: '${relationship.otherEntityField}'`);
+_%>
+/** The label of each relationship to one, the other field a list can be sorted on besides the id. */
+const SORT_LABELS: Record<string, string> = { <%- sortLabels.join(', ') %> };
+
+@Controller('api/<%= entityApiUrl %>')
+@UseGuards(AuthGuard, RolesGuard)
+@UseInterceptors(ClassSerializerInterceptor)
+<%_ if (authenticationType === 'jwt') { _%>
+@ApiBearerAuth()
+<%_ } else { _%>
+@ApiSecurity({})
+<%_ } _%>
+@ApiTags('<%= entityApiUrl %>')
+export class <%= entityClass %>Controller {
+  logger = new Logger('<%= entityClass %>Controller');
+
+  constructor(
+    private readonly <%= entityInstance %>Service: <%= entityClass %>Service,
+    private readonly headerUtil: HeaderUtil,
+  ) {}
+
+
+  @Get('/')
+<%_ if (nodejsReadRoles) { _%>
+  @Roles(<%- nodejsReadRoles %>)
+<%_ } _%>
+  @ApiResponse({
+    status: 200,
+    description: 'List all records',
+    type: <%= dtoClass %>,
+    isArray: true,
+  })
+  async getAll(@Req() req: Request): Promise<<%= dtoClass %> []>  {
+<%_ for (const relationship of nodejsMappedByRelationships.filter(relationship => relationship.relationshipOneToOne)) { _%>
+    // The records without <%= relationship.relationshipName %>, for the form of the other entity, like JHipster Spring Boot.
+    if (req.query.filter === '<%- relationship.relationshipName.toLowerCase() %>-is-null') {
+      return this.<%= entityInstance %>Service.findAllWhere<%- relationship.relationshipNameCapitalized %>IsNull();
+    }
+<%_ } _%>
+    const pageRequest: PageRequest = new PageRequest(
+      req.query.page,
+      req.query.size,
+      req.query.sort ?? '<%- primaryKey.name %>,ASC',
+      property => isSortableProperty(this.<%= entityInstance %>Service.metadata, property, { labels: SORT_LABELS }),
+    );
+<%_ if (pagination === 'no') { _%>
+    // Like JHipster Spring Boot, an entity without pagination lists all its records, without the pagination headers.
+    const [results] = await this.<%= entityInstance %>Service.findAndCount({
+      order: pageRequest.asOrder(),
+    });
+    return results;
+<%_ } else { _%>
+    const [results, count] = await this.<%= entityInstance %>Service.findAndCount({
+      skip: +pageRequest.page * pageRequest.size,
+      take: +pageRequest.size,
+      order: pageRequest.asOrder(),
+    });
+    this.headerUtil.addPaginationHeaders(req.res, new Page(results, count, pageRequest));
+    return results;
+<%_ } _%>
+  }
+
+  @Get('/:id')
+<%_ if (nodejsReadRoles) { _%>
+  @Roles(<%- nodejsReadRoles %>)
+<%_ } _%>
+  @ApiResponse({
+    status: 200,
+    description: 'The found record',
+    type: <%= dtoClass %>,
+  })
+  async getOne(<%- idParam %>): Promise<<%= dtoClass %>>  {
+    const <%= entityInstance %>DTO = await this.<%= entityInstance %>Service.findById(id);
+    if (!<%= entityInstance %>DTO) {
+      throw new NotFoundException();
+    }
+    return <%= entityInstance %>DTO;
+  }
+
+  @PostMethod('/')
+<%_ if (nodejsWriteRoles) { _%>
+  @Roles(<%- nodejsWriteRoles %>)
+<%_ } _%>
+  @ApiOperation({ summary: 'Create <%= entityInstance %>' })
+  @ApiResponse({
+    status: 201,
+    description: 'The record has been successfully created.',
+    type: <%= dtoClass %>,
+  })
+  @ApiResponse({ status: 400, description: 'The record already has an id.' })
+  @ApiResponse({ status: 403, description: 'Forbidden.' })
+  async post(@Req() req: Request, @Body() <%= entityInstance %>DTO: <%= dtoClass %>): Promise<<%= dtoClass %>>  {
+    if (<%= entityInstance %>DTO.id !== undefined && <%= entityInstance %>DTO.id !== null) {
+      // Like JHipster Spring Boot, a new record cannot have an id: it would update an existing one.
+      throw new BadRequestAlertException('A new <%= entityInstance %> cannot already have an ID', ENTITY_NAME, 'idexists');
+    }
+    const created = await this.<%= entityInstance %>Service.save(<%= entityInstance %>DTO, req.user?.login);
+    this.headerUtil.addEntityCreatedHeaders(req.res, ENTITY_NAME, created.id);
+    req.res.location(`/api/<%= entityApiUrl %>/${created.id}`);
+    return created;
+  }
+
+  @Put('/:id')
+<%_ if (nodejsWriteRoles) { _%>
+  @Roles(<%- nodejsWriteRoles %>)
+<%_ } _%>
+  @ApiOperation({ summary: 'Update <%= entityInstance %> with id' })
+  @ApiResponse({
+    status: 200,
+    description: 'The record has been successfully updated.',
+    type: <%= dtoClass %>,
+  })
+  @ApiResponse({ status: 400, description: 'Invalid id, or the record does not exist.' })
+  async putId(@Req() req: Request, <%- idParam %>, @Body() <%= entityInstance %>DTO: <%= dtoClass %>): Promise<<%= dtoClass %>>  {
+    await this.validateIdForUpdate(req, id, <%= entityInstance %>DTO);
+    const updated = await this.<%= entityInstance %>Service.update(<%= entityInstance %>DTO, req.user?.login);
+    this.headerUtil.addEntityUpdatedHeaders(req.res, ENTITY_NAME, id);
+    return updated;
+  }
+
+  @Delete('/:id')
+<%_ if (nodejsWriteRoles) { _%>
+  @Roles(<%- nodejsWriteRoles %>)
+<%_ } _%>
+  @ApiOperation({ summary: 'Delete <%= entityInstance %>' })
+  @ApiResponse({
+    status: 204,
+    description: 'The record has been successfully deleted.',
+  })
+  async deleteById(@Req() req: Request, <%- idParam %>): Promise<void>  {
+    this.headerUtil.addEntityDeletedHeaders(req.res, ENTITY_NAME, id);
+    return await this.<%= entityInstance %>Service.deleteById(id);
+  }
+
+  /**
+   * Checks the id of an update like JHipster Spring Boot: the body must have the id of the path,
+   * and the record must exist, otherwise answers 400.
+   */
+  private async validateIdForUpdate(req: Request, id: <%= pkType %>, <%= entityInstance %>DTO: Partial<<%= dtoClass %>> | undefined): Promise<<%= dtoClass %>> {
+    if (<%= entityInstance %>DTO?.id === undefined || <%= entityInstance %>DTO.id === null) {
+      throw new BadRequestAlertException('Invalid id', ENTITY_NAME, 'idnull');
+    }
+    if (String(<%= entityInstance %>DTO.id) !== String(id)) {
+      throw new BadRequestAlertException('Invalid ID', ENTITY_NAME, 'idinvalid');
+    }
+    const existing = await this.<%= entityInstance %>Service.findById(id);
+    if (!existing) {
+      throw new BadRequestAlertException('Entity not found', ENTITY_NAME, 'idnotfound');
+    }
+    return existing;
+  }
+}

package/generators/node-server/templates/server/src/entities/_entityFileName_/_entityFileName_.entity.ts.ejs

@@ -0,0 +1,110 @@
+import { <%_ if (databaseType === 'mongodb') { _%> ObjectIdColumn <%_ } else { _%> PrimaryGeneratedColumn <%_ } _%>, Entity, Column <%_ if (databaseType !== 'mongodb') { _%>, JoinColumn, OneToOne, ManyToOne, OneToMany, ManyToMany, JoinTable, type Relation <%_ } _%> } from 'typeorm';
+import { BaseEntity } from '../../common/database/base.entity.ts';
+<%_ if (nodejsColumnTransformers.length > 0) { _%>
+import { <%- nodejsColumnTransformers.map(name => `${name}Transformer`).join(', ') %> } from '../../common/database/column-transformers.ts';
+<%_ } _%>
+<%_ if (nodejsColumnTypeImports.length > 0) { _%>
+import { <%- nodejsColumnTypeImports.join(', ') %> } from '../../common/database/column-types.ts';
+<%_ } _%>
+
+<%_
+let isUserRelationship = false;
+const uniqueEntities = {};
+const uniqueEnums = {};
+
+for (idx in fields) {
+    if (fields[idx].fieldIsEnum && (
+            !uniqueEnums[fields[idx].fieldType] || (uniqueEnums[fields[idx].fieldType] && fields[idx].fieldValues.length !== 0))) {
+        uniqueEnums[fields[idx].fieldType] = this._.kebabCase(fields[idx].fieldType);
+    }
+}
+for (idx in relationships) {
+    const relationship = relationships[idx];
+    const otherEntityClass = relationship.otherEntity.persistClass;
+    if (relationship.otherEntity.entityClass === 'User'){
+        isUserRelationship = true;
+    }
+    else if (!uniqueEntities[otherEntityClass] && otherEntityClass != persistClass) {
+        uniqueEntities[otherEntityClass] = relationship.otherEntity.nodejsEntityPath;
+    }
+}
+_%>
+
+<%_ Object.keys(uniqueEntities).forEach(function(entityClass) { _%>
+import { <%= entityClass %> } from '../../<%= uniqueEntities[entityClass] %>';
+<%_ }); _%>
+<%_ Object.keys(uniqueEnums).forEach(function(enumClass) { _%>
+import { <%= enumClass %> } from '../enumeration/<%= uniqueEnums[enumClass] %>.ts';
+<%_ }); _%>
+
+<%_ if (isUserRelationship === true) { _%>
+import { <%= user.persistClass %> } from '../../users/user.entity.ts';
+<%_ } _%>
+
+<%_ if (typeof javadoc == 'undefined') { _%>
+/**
+ * A <%= persistClass %>.
+ */
+<%_ } else { _%>
+<%- formatAsClassJavadoc(javadoc) %>
+<%_ } _%>
+@Entity('<%= entityTableName %>')
+export class <%= persistClass %> extends BaseEntity  {
+
+<%_ if (databaseTypeMongodb) { _%>
+  @ObjectIdColumn({ name: '_<%- primaryKey.name %>' })
+<%_ } else if (databaseTypeSql) { _%>
+  @PrimaryGeneratedColumn(<%- primaryKey.typeUUID ? "'uuid'" : '' %>)
+<%_ } _%>
+  <%- primaryKey.name %>?: <%- primaryKey.tsType %>;
+
+<%_ for (const field of fields.filter(field => !field.id)) {
+    if (typeof field.javadoc !== 'undefined') { _%>
+<%- formatAsFieldJavadoc(field.javadoc) %>
+    <%_ }
+    const { fieldType, fieldTypeBlobContent, fieldName } = field; _%>
+    @Column({ <%- field.nodejsColumnOptions.join(', ') %> })
+    <%= fieldName %><%- field.fieldValidationRequired ? '!' : '?' %>: <%= field.nodejsFieldType %>;
+
+    <%_ if ((fieldType === 'byte[]' || fieldType === 'ByteBuffer') && fieldTypeBlobContent !== 'text') { _%>
+    @Column({ <%- field.nodejsContentTypeColumnOptions.join(', ') %> })
+    <%= fieldName %>ContentType<%- field.fieldValidationRequired ? '!' : '?' %>: string;
+    <%_ }
+    } _%>
+
+    <%_ for (const relationship of relationships) {
+        const { otherEntityRelationshipName, otherEntityRelationshipNamePlural, relationshipFieldName, relationshipFieldNamePlural, ownerSide, otherEntityUser } = relationship;
+        const otherEntityClass = relationship.otherEntity.persistClass;
+        if (relationship.relationshipOneToMany) { _%>
+    @OneToMany(() => <%= otherEntityClass %> <%_ if (!otherEntityUser) { _%>, other => other.<%= otherEntityRelationshipName %><%_ } _%>)
+    <%= relationshipFieldNamePlural %><%- relationship.relationshipRequired ? '!' : '?' %>: Relation<<%= otherEntityClass %>[]>;
+
+    <%_ } else if (relationship.relationshipManyToOne) { _%>
+    @ManyToOne(() => <%= otherEntityClass %> <%_ if (!ownerSide && !otherEntityUser) { _%>, other => other.<%= otherEntityRelationshipNamePlural %>  <%_ } _%>)
+    <%= relationshipFieldName %><%- relationship.relationshipRequired ? '!' : '?' %>: Relation<<%= otherEntityClass %>>;
+
+    <%_ } else if (relationship.relationshipManyToMany) { _%>
+    @ManyToMany(() => <%= otherEntityClass %> )
+        <%_ if (relationship.nodejsJoinTable) { _%>
+    @JoinTable({
+        name: '<%= relationship.nodejsJoinTable.name %>',
+        joinColumn: { name: '<%= relationship.nodejsJoinTable.joinColumn.name %>', referencedColumnName: '<%= relationship.nodejsJoinTable.joinColumn.referencedColumnName %>' },
+        inverseJoinColumn: { name: '<%= relationship.nodejsJoinTable.inverseJoinColumn.name %>', referencedColumnName: '<%= relationship.nodejsJoinTable.inverseJoinColumn.referencedColumnName %>' }
+    })
+        <%_ } _%>
+    <%= relationshipFieldNamePlural %><%- relationship.relationshipRequired ? '!' : '?' %>: Relation<<%= otherEntityClass %>[]>;
+
+    <%_ } else { _%>
+    <%_ if (ownerSide) { _%>
+    @OneToOne(() => <%= otherEntityClass %>)
+    @JoinColumn()
+    <%_ } else { _%>
+    @OneToOne(() => <%= otherEntityClass %>, other => other.<%= otherEntityRelationshipName %>)
+    <%_ } _%>
+    <%= relationshipFieldName %><%- relationship.relationshipRequired ? '!' : '?' %>: Relation<<%= otherEntityClass %>>;
+
+    <%_ }
+    } _%>
+    // jhipster-needle-entity-add-field - JHipster will add fields here, do not remove
+
+}

package/generators/node-server/templates/server/src/entities/_entityFileName_/_entityFileName_.mapper.ts.ejs

@@ -0,0 +1,37 @@
+<%_
+// The relationships the other entity stores (nodejsMappedByRelationships): never stored from this entity.
+const inverseProperties = nodejsMappedByRelationships.map(relationship => relationship.propertyName);
+_%>
+import { <%= persistClass %> } from './<%= entityFileName %>.entity.ts';
+import { <%= dtoClass %> } from './dto/<%= entityFileName %>.dto.ts';
+
+
+/**
+ * A <%= entityClass %> mapper object.
+ */
+export class <%= entityClass %>Mapper {
+
+  static fromDTOtoEntity(entityDTO: <%= dtoClass %>): <%= persistClass %>;
+  static fromDTOtoEntity(entityDTO: <%= dtoClass %> | null | undefined): <%= persistClass %> | undefined;
+  static fromDTOtoEntity(entityDTO: <%= dtoClass %> | null | undefined): <%= persistClass %> | undefined {
+    if (!entityDTO) {
+      return undefined;
+    }
+<%_ if (inverseProperties.length > 0) { _%>
+    // The relationships the other entity owns are not stored from this one.
+    const { <%- inverseProperties.map(property => `${property}: _${property}`).join(', ') %>, ...fields } = entityDTO;
+    return Object.assign(new <%= persistClass %>(), fields);
+<%_ } else { _%>
+    return Object.assign(new <%= persistClass %>(), entityDTO);
+<%_ } _%>
+  }
+
+  static fromEntityToDTO(entity: <%= persistClass %>): <%= dtoClass %>;
+  static fromEntityToDTO(entity: <%= persistClass %> | null | undefined): <%= dtoClass %> | undefined;
+  static fromEntityToDTO(entity: <%= persistClass %> | null | undefined): <%= dtoClass %> | undefined {
+    if (!entity) {
+      return undefined;
+    }
+    return Object.assign(new <%= dtoClass %>(), entity);
+  }
+}

package/generators/node-server/templates/server/src/entities/_entityFileName_/_entityFileName_.module.ts.ejs

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { <%= entityClass %> } from './<%= entityFileName %>.entity.ts';
+import { <%= entityClass %>Controller } from './<%= entityFileName %>.controller.ts';
+import { <%= entityClass %>Service } from './<%= entityFileName %>.service.ts';
+
+
+@Module({
+  imports: [TypeOrmModule.forFeature([<%= entityClass %>])],
+  controllers: [<%= entityClass %>Controller],
+  providers: [<%= entityClass %>Service],
+  exports: [<%= entityClass %>Service],
+})
+export class <%= entityClass %>Module {}