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

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

@@ -0,0 +1,123 @@
+import { Injectable, HttpException, HttpStatus, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { EntityMetadata, FindManyOptions, FindOneOptions, Repository } from 'typeorm';
+import { <%= entityClass %> } from './<%= entityFileName %>.entity.ts';
+import { <%= dtoClass %> }  from './dto/<%= entityFileName %>.dto.ts';
+import { <%= entityClass %>Mapper }  from './<%= entityFileName %>.mapper.ts';
+<%_ if (databaseType === 'mongodb') { _%>
+import { updatableProperties } from '../../common/updatable-properties.ts';
+<%_ if (databaseTypeMongodb) { _%>
+import { ObjectId } from 'mongodb';
+import { documentOrder } from '../../common/sortable-properties.ts';
+<%_ } _%>
+<%_ } _%>
+
+<%_
+// The relationships the entity stores (the persistableRelationships of JHipster), loaded with it.
+const eagerLoadRelations = persistableRelationships.map(relationship => relationship.propertyName);
+const pkType = primaryKey.tsType;
+_%>
+<%_ if (typeormRelationsSupport && eagerLoadRelations.length > 0) { _%>
+const relations = {
+  <%_ for (const rel of eagerLoadRelations) { _%>
+  '<%= rel %>': true,
+  <%_ } _%>
+} as const;
+
+<%_ } _%>
+@Injectable()
+export class <%= entityClass %>Service {
+    logger = new Logger('<%= entityClass %>Service');
+
+    constructor(@InjectRepository(<%= entityClass %>) private <%= entityInstance %>Repository: Repository<<%= entityClass %>>) {}
+
+    /** The TypeORM metadata of the entity, the sort of its lists is validated with. */
+    get metadata(): EntityMetadata {
+        return this.<%= entityInstance %>Repository.metadata;
+    }
+
+      async findById(id: <%= pkType %>): Promise<<%= dtoClass %> | undefined> {
+<%_ if (databaseTypeMongodb) { _%>
+        // An id that is not an ObjectId is the one of no document, like an unknown id of JHipster Spring Boot.
+        if (!ObjectId.isValid(id)) {
+          return undefined;
+        }
+<%_ } _%>
+        const result = await this.<%= entityInstance %>Repository.findOne({
+<%_ if (typeormRelationsSupport && eagerLoadRelations.length > 0) { _%>
+          relations,
+<%_ } _%>
+          where: { id },
+        });
+        return <%= entityClass %>Mapper.fromEntityToDTO(result);
+      }
+
+      async findByFields(options: FindOneOptions<<%= dtoClass %>>): Promise<<%= dtoClass %> | undefined> {
+        const result = await this.<%= entityInstance %>Repository.findOne(options);
+        return <%= entityClass %>Mapper.fromEntityToDTO(result);
+      }
+
+      async findAndCount(options: FindManyOptions<<%= dtoClass %>>): Promise<[<%= dtoClass %>[], number]> {
+        const resultList = await this.<%= entityInstance %>Repository.findAndCount(
+<%_ if (typeormRelationsSupport && eagerLoadRelations.length > 0) { _%>
+          { ...options, relations },
+<%_ } else if (databaseTypeMongodb) { _%>
+          { ...options, order: documentOrder(this.metadata, options.order) },
+<%_ } else { _%>
+          options,
+<%_ } _%>
+        );
+        const <%= entityInstance %>DTO: <%= dtoClass %>[] = [];
+        if (resultList && resultList[0]) {
+            resultList[0].forEach(<%= entityInstance %> => <%= entityInstance %>DTO.push(<%= entityClass %>Mapper.fromEntityToDTO(<%= entityInstance %>)));
+            resultList[0] = <%= entityInstance %>DTO;
+        }
+        return resultList;
+      }
+
+<%_ for (const relationship of nodejsMappedByRelationships.filter(relationship => relationship.relationshipOneToOne)) { _%>
+      /** The records without <%= relationship.relationshipName %>, like the findAllWhere<%- relationship.relationshipNameCapitalized %>IsNull of JHipster Spring Boot. */
+      async findAllWhere<%- relationship.relationshipNameCapitalized %>IsNull(): Promise<<%= dtoClass %>[]> {
+        const results = await this.<%= entityInstance %>Repository.find({ relations: { <%= relationship.propertyName %>: true } });
+        return results.filter(<%= entityInstance %> => !<%= entityInstance %>.<%= relationship.propertyName %>).map(<%= entityInstance %> => <%= entityClass %>Mapper.fromEntityToDTO(<%= entityInstance %>));
+      }
+
+<%_ } _%>
+      async save(<%= entityInstance %>DTO: <%= dtoClass %>, creator?: string): Promise<<%= dtoClass %>> {
+        const entity = <%= entityClass %>Mapper.fromDTOtoEntity(<%= entityInstance %>DTO);
+        if (creator) {
+            entity.createdBy = creator;
+            entity.lastModifiedBy = creator;
+        }
+        const result = await this.<%= entityInstance %>Repository.save(entity);
+        return <%= entityClass %>Mapper.fromEntityToDTO(result);
+      }
+
+      async update(<%= entityInstance %>DTO: <%= dtoClass %>, updater?: string): Promise<<%= dtoClass %>> {
+        const entity = <%= entityClass %>Mapper.fromDTOtoEntity(<%= entityInstance %>DTO);
+        if (updater) {
+            entity.lastModifiedBy = updater;
+        }
+      <%_ if (databaseType === 'mongodb') { _%>
+        await this.<%= entityInstance %>Repository.update(entity.id!, updatableProperties(this.<%= entityInstance %>Repository.metadata, entity));
+      <%_ } else { _%>
+        await this.<%= entityInstance %>Repository.save(entity);
+      <%_ } _%>
+        // The stored entity, with its relationships and audit fields, rather than the request.
+        const result = await this.findById(entity.id!);
+        if (!result) {
+          throw new HttpException('Entity not found', HttpStatus.NOT_FOUND);
+        }
+        return result;
+      }
+
+      async deleteById(id: <%= pkType %>): Promise<void> {
+<%_ if (databaseTypeMongodb) { _%>
+        if (!ObjectId.isValid(id)) {
+          return;
+        }
+<%_ } _%>
+        await this.<%= entityInstance %>Repository.delete(id);
+      }
+
+}

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

@@ -0,0 +1,99 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Allow<% if (anyPropertyHasValidation || fields.some(field => field.fieldIsEnum || field.nodejsTypeValidators.length > 0)) { %>, IsNotEmpty, IsOptional, IsEnum, MinLength, MaxLength, Length, Min, Max, Matches, IsInt, IsNumber, IsBoolean, IsUUID, IsISO8601<% } %> } from 'class-validator';
+<%_ if (databaseTypeMongodb) { _%>
+import { Transform } from 'class-transformer';
+<%_ } _%>
+import { BaseDTO<% if (relationships.length > 0) { %>, type RelatedDTO<% } %> } from '../../../common/dto/base.dto.ts';
+
+<%_
+let isUserRelationship = false;
+const uniqueEntities = {};
+const uniqueEnums = {};
+const fieldsWithoutId = [];
+
+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);
+    }
+    if (fields[idx].fieldName !== 'id') {
+        fieldsWithoutId.push(fields[idx]);
+    }
+}
+for (idx in relationships) {
+    const relationship = relationships[idx];
+    const otherDto = relationship.otherEntity.dtoClass;
+    if (relationship.otherEntity.entityClass === 'User'){
+        isUserRelationship = true;
+    }
+    else if (!uniqueEntities[otherDto] && otherDto != dtoClass) {
+        uniqueEntities[otherDto] = relationship.otherEntity.nodejsDtoPath;
+    }
+}
+_%>
+
+<%_ Object.keys(uniqueEntities).forEach(function(entityDto) { _%>
+import { <%= entityDto %> } from '../../../<%= uniqueEntities[entityDto] %>';
+<%_ }); _%>
+<%_ Object.keys(uniqueEnums).forEach(function(enumClass) { _%>
+import { <%= enumClass %> } from '../../enumeration/<%= uniqueEnums[enumClass] %>.ts';
+<%_ }); _%>
+
+<%_ if (isUserRelationship === true) { _%>
+import { <%= user.dtoClass%> } from '../../../users/dto/user.dto.ts';
+<%_ } _%>
+
+/**
+ * A <%= dtoClass %> object.
+ */
+export class <%= dtoClass %> extends BaseDTO {
+<%_ if (databaseTypeMongodb) { _%>
+  @Transform(({ value }) => value?.toHexString ? value?.toHexString() : value, {toPlainOnly: true})
+<%_ } _%>
+  @Allow()
+  <%= primaryKey.name %>?: <%= primaryKey.tsType %>;
+
+    <%_ for (idx in fieldsWithoutId) {
+        const field = fieldsWithoutId[idx];
+       if (typeof field.javadoc !== 'undefined') { _%>
+    <%- formatAsFieldJavadoc(field.javadoc) %>
+    <%_ }
+        const required = field.fieldValidationRequired;
+        const fieldValidate = field.fieldValidate;
+        const fieldType = field.fieldType;
+        const fieldTypeBlobContent = field.fieldTypeBlobContent;
+        const fieldName = field.fieldName;
+        const fieldNameUnderscored = field.fieldNameUnderscored;
+        const fieldNameAsDatabaseColumn = field.fieldNameAsDatabaseColumn;
+        if (fieldValidate === true || field.fieldIsEnum || field.nodejsTypeValidators.length > 0) {
+            _%>
+            <%- include('../../../common/field_validators', { field }); -%>
+        <%_ } else { _%>
+            @Allow()
+        <%_ } _%>
+            <%_ if (field.fieldIsEnum) { _%>
+            @ApiProperty({ enum: <%= fieldType %>, <%_ if (typeof field.javadoc != 'undefined') { _%> description: '<%- formatAsApiDescription(field.javadoc) %>' <%_ } else { _%> description: '<%= fieldName %> enum field' <%_ } if (!required) { _%>, required: false <%_ } _%>})
+            <%_ } else { _%>
+            @ApiProperty({ <%_ if (typeof field.javadoc != 'undefined') { _%> description: '<%- formatAsApiDescription(field.javadoc) %>' <%_ } else { _%> description: '<%= fieldName %> field' <%_ } if (!required) { _%>, required: false <%_ } _%>})
+            <%_ } _%>
+        <%= fieldName %><%- field.fieldValidationRequired ? '!' : '?' %>: <%= field.nodejsFieldType %>;
+
+        <%_ if ((fieldType === 'byte[]' || fieldType === 'ByteBuffer') && fieldTypeBlobContent !== 'text') { _%>
+
+        @Allow()
+        <%= fieldName %>ContentType<%- field.fieldValidationRequired ? '!' : '?' %>: string;
+        <%_ }
+        } _%>
+
+        <%_
+  for (const relationship of relationships) {
+        if (typeof relationship.javadoc != 'undefined') { _%>
+  <%- formatAsFieldJavadoc(relationship.javadoc) %>
+        <%_ } _%>
+  @Allow()
+  @ApiProperty({ type: () => <%= relationship.otherEntity.dtoClass %><%- relationship.collection ? ', isArray: true' : '' %>, <%_ if (typeof relationship.javadoc != 'undefined') { _%>  description: '<%- formatAsApiDescription(relationship.javadoc) %>' <%_ } else { _%> description: '<%= relationship.propertyName %> relationship' <%_ } _%> })
+  <%= relationship.propertyName %><%- relationship.relationshipRequired ? '!' : '?' %>: RelatedDTO<<%= relationship.otherEntity.dtoClass %><%- relationship.collection ? '[]' : '' %>>;
+  <%_ } _%>
+
+  // jhipster-needle-entity-add-field - JHipster will add fields here, do not remove
+}

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

@@ -0,0 +1,49 @@
+import * as path from 'path';
+
+import { Module } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { HelperOptions } from 'handlebars';
+import { MailerModule, MailerOptions } from '@nestjs-modules/mailer';
+import { HandlebarsAdapter } from '@nestjs-modules/mailer/adapters/handlebars.adapter';
+
+import { MailService } from './mail.service.ts';
+
+/** The templates of the account mails, like the templates/mail of JHipster Spring Boot. */
+export const mailTemplatesFolder = path.join(import.meta.dirname, '../templates/mail');
+
+/**
+ * The helpers of the templates: message, the message of a key in the language of the mail, its {0}, {1}... replaced by
+ * the parameters, like the #{key(...)} of Thymeleaf. The messages are the ones of the context of the mail.
+ */
+export const mailTemplateHelpers = {
+  message(key: string, ...parameters: unknown[]): string {
+    const { data } = parameters.pop() as HelperOptions;
+    const messages = (data?.root?.messages ?? {}) as Record<string, string>;
+    const values = parameters.map(value => (typeof value === 'string' || typeof value === 'number' ? `${value}` : ''));
+    return (messages[key] ?? key).replace(/\{(\d+)\}/g, (_, index: string) => values[Number(index)] ?? '');
+  },
+};
+
+/**
+ * The SMTP server of the mail properties, like spring.mail, and the Handlebars templates of the mails: they only
+ * interpolate values, escaped, and call the helpers of the server, they run no code.
+ */
+export function mailerOptions(configService: ConfigService): MailerOptions {
+  const username = configService.get<string>('mail.username');
+  return {
+    transport: {
+      host: configService.get<string>('mail.host'),
+      port: Number(configService.get('mail.port')),
+      auth: username ? { user: username, pass: configService.get<string>('mail.password') } : undefined,
+    },
+    defaults: { from: configService.get<string>('jhipster.mail.from') },
+    template: { dir: mailTemplatesFolder, adapter: new HandlebarsAdapter(mailTemplateHelpers), options: { strict: true } },
+  };
+}
+
+@Module({
+  imports: [MailerModule.forRootAsync({ inject: [ConfigService], useFactory: mailerOptions })],
+  providers: [MailService],
+  exports: [MailService],
+})
+export class MailModule {}

package/generators/node-server/templates/server/src/mail/mail.service.spec.ts.ejs

@@ -0,0 +1,105 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { MAILER_OPTIONS, MailerService } from '@nestjs-modules/mailer';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { Test, TestingModule } from '@nestjs/testing';
+
+import { MailModule, mailerOptions } from './mail.module.ts';
+import { MailService, parseProperties } from './mail.service.ts';
+
+describe('MailService', () => {
+  let moduleRef: TestingModule;
+  let mailService: MailService;
+  let sendMail: ReturnType<typeof vi.spyOn>;
+
+  const user = { login: 'mailuser', email: 'mailuser@localhost.it', password: '', langKey: 'en', activationKey: 'activationKey', resetKey: 'resetKey' };
+
+  /** The mail the JSON transport of nodemailer gives back instead of sending it. */
+  const sentMail = async (): Promise<{ from: { address: string }; subject: string; html: string }> =>
+    JSON.parse(((await sendMail.mock.results[0].value) as { message: string }).message);
+
+  beforeEach(async () => {
+    moduleRef = await Test.createTestingModule({
+      imports: [
+        ConfigModule.forRoot({
+          isGlobal: true,
+          ignoreEnvFile: true,
+          load: [() => ({ mail: { host: 'localhost', port: 25 }, jhipster: { mail: { from: '<%= baseName %>@localhost', 'base-url': 'http://127.0.0.1:<%= serverPort %>' } } })],
+        }),
+        MailModule,
+      ],
+    })
+      .overrideProvider(MAILER_OPTIONS)
+      .useFactory({ factory: (configService: ConfigService) => ({ ...mailerOptions(configService), transport: { jsonTransport: true } }), inject: [ConfigService] })
+      .compile();
+    mailService = moduleRef.get(MailService);
+    sendMail = vi.spyOn(moduleRef.get(MailerService), 'sendMail');
+  });
+
+  afterEach(async () => {
+    await moduleRef.close();
+  });
+
+  it('should send the activation mail with the activation link', async () => {
+    await mailService.sendActivationEmail(user);
+
+    const mail = await sentMail();
+    expect(mail.from.address).toBe('<%= baseName %>@localhost');
+    expect(mail.subject).toBe('<%- baseName %> account activation');
+    expect(mail.html).toContain('<a href="http://127.0.0.1:<%= serverPort %>/account/activate?key=activationKey">');
+    expect(mail.html).toContain('<p>Dear mailuser</p>');
+  });
+
+  it('should send the creation mail with the link to set the password', async () => {
+    await mailService.sendCreationEmail(user);
+
+    const mail = await sentMail();
+    expect(mail.subject).toBe('<%- baseName %> account activation');
+    expect(mail.html).toContain('<a href="http://127.0.0.1:<%= serverPort %>/account/reset/finish?key=resetKey">');
+  });
+
+  it('should send the password reset mail with the reset link', async () => {
+    await mailService.sendPasswordResetMail(user);
+
+    const mail = await sentMail();
+    expect(mail.subject).toBe('<%- baseName %> password reset');
+    expect(mail.html).toContain('<a href="http://127.0.0.1:<%= serverPort %>/account/reset/finish?key=resetKey">');
+  });
+
+  it('should escape the user values in the mail', async () => {
+    await mailService.sendActivationEmail({ ...user, login: '<b>mailuser</b>' });
+
+    expect((await sentMail()).html).toContain('<p>Dear &lt;b&gt;mailuser&lt;/b&gt;</p>');
+  });
+
+  it('should use the default messages for a language without its messages file', async () => {
+    await mailService.sendPasswordResetMail({ ...user, langKey: 'unknown' });
+
+    expect((await sentMail()).subject).toBe('<%- baseName %> password reset');
+  });
+
+  it('should use the default messages for a langKey that is not a language tag', async () => {
+    await mailService.sendPasswordResetMail({ ...user, langKey: '../config/application' });
+
+    expect((await sentMail()).subject).toBe('<%- baseName %> password reset');
+  });
+
+  it('should not send a mail to a user without email', async () => {
+    await mailService.sendActivationEmail({ ...user, email: '' });
+
+    expect(sendMail).not.toHaveBeenCalled();
+  });
+
+  it('should not fail when the mail could not be sent', async () => {
+    sendMail.mockRejectedValue(new Error('Connection refused'));
+
+    await expect(mailService.sendActivationEmail(user)).resolves.toBeUndefined();
+  });
+
+  it('should parse the messages of a properties file', () => {
+    expect(parseProperties('# comment\nemail.greeting=Caro {0}\nemail.title = \\u00c9quipe\n')).toEqual({
+      'email.greeting': 'Caro {0}',
+      'email.title': 'Équipe',
+    });
+  });
+});

package/generators/node-server/templates/server/src/mail/mail.service.ts.ejs

@@ -0,0 +1,120 @@
+import { existsSync, readFileSync } from 'fs';
+import * as path from 'path';
+
+import { Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { MailerService } from '@nestjs-modules/mailer';
+
+import { <%= user.dtoClass %> } from '../users/dto/user.dto.ts';
+
+/** A language tag of JHipster, like pt-br: the langKey of a user, which the user can change, read as a file name. */
+const LANGUAGE_TAG = /^[a-zA-Z0-9-]+$/;
+
+const i18nFolder = path.join(import.meta.dirname, '../i18n');
+
+/** The messages of a .properties file, like the ones of the MessageSource of Spring. */
+export function parseProperties(content: string): Record<string, string> {
+  const messages: Record<string, string> = {};
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('!')) {
+      continue;
+    }
+    const separator = trimmed.search(/[=:]/);
+    if (separator > 0) {
+      messages[trimmed.substring(0, separator).trim()] = trimmed
+        .substring(separator + 1)
+        .trim()
+        .replace(/\\u([0-9a-fA-F]{4})/g, (_, code: string) => String.fromCharCode(parseInt(code, 16)))
+        .replace(/\\(.)/g, '$1');
+    }
+  }
+  return messages;
+}
+
+/**
+ * Sends the account mails, like the MailService of JHipster Spring Boot: the activation mail of a registered user, the
+ * creation mail of a user created by an administrator and the password reset mail, in the language of the user (its
+ * langKey), with the SMTP server of the mail properties. Like the @Async methods of Spring, a mail is sent without
+ * failing the request: a mail that could not be sent is logged.
+ */
+@Injectable()
+export class MailService {
+  logger = new Logger('MailService');
+
+  private readonly defaultMessages: Record<string, string>;
+
+  private readonly languageMessages = new Map<string, Record<string, string>>();
+
+  constructor(
+    private readonly mailerService: MailerService,
+    private readonly configService: ConfigService,
+  ) {
+    this.defaultMessages = parseProperties(readFileSync(path.join(i18nFolder, 'messages.properties'), 'utf8'));
+  }
+
+  async sendActivationEmail(user: <%= user.dtoClass %>): Promise<void> {
+    this.logger.debug(`Sending activation email to '${user.email}'`);
+    await this.sendEmailFromTemplate(user, 'activationEmail', 'email.activation.title');
+  }
+
+  async sendCreationEmail(user: <%= user.dtoClass %>): Promise<void> {
+    this.logger.debug(`Sending creation email to '${user.email}'`);
+    await this.sendEmailFromTemplate(user, 'creationEmail', 'email.activation.title');
+  }
+
+  async sendPasswordResetMail(user: <%= user.dtoClass %>): Promise<void> {
+    this.logger.debug(`Sending password reset email to '${user.email}'`);
+    await this.sendEmailFromTemplate(user, 'passwordResetEmail', 'email.reset.title');
+  }
+
+  /**
+   * The mail of a template of templates/mail, like the sendEmailFromTemplate of JHipster Spring Boot: rendered with the
+   * user, the base URL of the client and the messages of the language of the user (the message helper of the templates).
+   */
+  async sendEmailFromTemplate(user: <%= user.dtoClass %>, template: string, titleKey: string): Promise<void> {
+    if (!user.email) {
+      this.logger.debug(`Email doesn't exist for user '${user.login}'`);
+      return;
+    }
+    const messages = this.messages(user.langKey);
+    const message = (key: string, ...args: string[]): string =>
+      (messages[key] ?? this.defaultMessages[key] ?? key).replace(/\{(\d+)\}/g, (_, index: string) => args[Number(index)] ?? '');
+    const subject = message(titleKey);
+    this.logger.debug(`Send email to '${user.email}' with subject '${subject}'`);
+    try {
+      await this.mailerService.sendMail({
+        to: user.email,
+        subject,
+        template,
+        context: {
+          user,
+          baseUrl: this.configService.get<string>('jhipster.mail.base-url') ?? '',
+          langKey: user.langKey ?? 'en',
+          messages: { ...this.defaultMessages, ...messages },
+        },
+      });
+      this.logger.debug(`Sent email to User '${user.email}'`);
+    } catch (error) {
+      this.logger.warn(`Email could not be sent to user '${user.email}': ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * The messages of a language, from its file named by its language tag (messages_pt-br.properties, written by the
+   * server:i18n generator of JHipster), the default ones (messages.properties) for a language without its own file,
+   * like a language added after the generation of the application.
+   */
+  private messages(langKey?: string): Record<string, string> {
+    const fileName = langKey && LANGUAGE_TAG.test(langKey) ? `messages_${langKey}.properties` : undefined;
+    if (!fileName || !existsSync(path.join(i18nFolder, fileName))) {
+      return this.defaultMessages;
+    }
+    let messages = this.languageMessages.get(fileName);
+    if (!messages) {
+      messages = parseProperties(readFileSync(path.join(i18nFolder, fileName), 'utf8'));
+      this.languageMessages.set(fileName, messages);
+    }
+    return messages;
+  }
+}

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

@@ -0,0 +1,114 @@
+// The .env file, loaded before the configuration (an import runs before the code of this module).
+import 'dotenv/config';
+import { NestFactory } from '@nestjs/core';
+<%_ if (serviceDiscoveryEureka) { _%>
+import cloudConfigClient from 'cloud-config-client';
+<%_ } _%>
+import { AppModule } from './app.module.ts';
+import { configureApp } from './app.config.ts';
+import { setupSwagger } from './swagger.ts';
+import { <% if (serviceDiscoveryEureka) { %>activeProfiles, <% } %>config, isProfileActive } from './config.ts';
+import { httpsOptions } from './tls.ts';
+<%_ if (serviceDiscoveryEureka) { _%>
+import { EurekaService } from './registry/eureka.service.ts';
+<%_ } _%>
+<%_ if (serviceDiscoveryConsul) { _%>
+import { ConsulService } from './registry/consul.service.ts';
+<%_ } _%>
+import { Logger } from '@nestjs/common';
+import { LevelsConsoleLogger, loggerLevels } from './common/logging.ts';
+<%_ if (!skipClient) { _%>
+import * as fs from 'fs';
+<%_ } _%>
+<%_ if (authenticationType === 'oauth2') { _%>
+import passport from 'passport';
+<%_ } _%>
+// The levels of the loggers (logging.level.* of the configuration), like Spring Boot, the loggers endpoint changes them.
+loggerLevels.configure(config);
+const appLogger = new LevelsConsoleLogger();
+Logger.overrideLogger(appLogger);
+const logger: Logger = new Logger('Main');
+const port = process.env.NODE_SERVER_PORT || config.get('server.port');
+<%_ if (serviceDiscoveryEureka) { _%>
+const useJHipsterRegistry = config.get('eureka.client.enabled');
+<%_ } _%>
+
+async function bootstrap(): Promise<void> {
+<%_ if (serviceDiscoveryEureka) { _%>
+  await loadCloudConfig();
+  loggerLevels.configure(config);
+<%_ } _%>
+
+  // abortOnError: false: an error of the initialization (the database still unreachable after the retries) rejects
+  // to the catch of bootstrap() below, instead of Nest stopping the process by itself.
+  const tlsOptions = httpsOptions();
+  const app = await NestFactory.create(AppModule, { abortOnError: false, logger: appLogger, httpsOptions: tlsOptions });
+  // Close the application (HTTP server, database connections) on SIGTERM, the signal docker stop sends.
+  app.enableShutdownHooks();
+  // CORS, global validation<% if (authenticationUsesCsrf) { %>, HTTP settings and sessions<% } else { %> and HTTP settings<% } %>, shared with the e2e tests.
+  configureApp(app);
+
+  <%_ if (authenticationType === 'oauth2') { _%>
+
+  app.use(passport.initialize());
+  app.use(passport.session());
+  <%_ } _%>
+
+  <%_ if (!skipClient) { _%>
+  const staticClientPath = config.getClientPath();
+  if (fs.existsSync(staticClientPath)) {
+    logger.log(`Serving static client resources on ${staticClientPath}`);
+  } else {
+    logger.log(`No client it has been found`);
+  }
+  <%_ } else { _%>
+    logger.log(`The client is not been generated`);
+  <%_ } _%>
+  // The API documentation of the api-docs profile, like JHipster Spring Boot.
+  if (isProfileActive('api-docs')) {
+    setupSwagger(app);
+  }
+
+  await app.listen(port);
+  logger.log(`Application listening on ${tlsOptions ? 'https' : 'http'} port ${port}`);
+<%_ if (serviceDiscoveryEureka) { _%>
+  // Registered once it listens, so a gateway routes to the application once it answers.
+  app.get(EurekaService).register(Number(port));
+<%_ } _%>
+<%_ if (serviceDiscoveryConsul) { _%>
+  // Registered once it listens, so a gateway routes to the application once it answers.
+  await app.get(ConsulService).register(Number(port));
+<%_ } _%>
+}
+
+<%_ if (serviceDiscoveryEureka) { _%>
+async function loadCloudConfig(): Promise<void> {
+  if (useJHipsterRegistry) {
+    const endpoint = config.get('cloud.config.uri') || 'http://admin:admin@localhost:8761/config';
+    logger.log(`Loading cloud config from ${endpoint}`);
+
+    const cloudConfig = await cloudConfigClient.load({
+      context: process.env,
+      endpoint,
+      name: config.get('cloud.config.name'),
+      // The active profiles, like Spring Cloud Config.
+      profiles: activeProfiles,
+      // The label (git branch, tag or commit) of the configuration, like spring.cloud.config.label.
+      label: config.get('cloud.config.label'),
+      // auth: {
+      //   user: config.get('jhipster.registry.username') || 'admin',
+      //   pass: config.get('jhipster.registry.password') || 'admin'
+      // }
+    });
+    config.addAll(cloudConfig.properties);
+  }
+}
+
+<%_ } _%>
+
+bootstrap().catch((error: unknown) => {
+  // A failed start (database unreachable after the retries, port in use, cloud config not loaded, ...) stops the process
+  // with a failure exit code, for the container orchestrator or the process manager to see it and restart it.
+  logger.error(`Application failed to start: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error.stack : undefined);
+  process.exit(1);
+});

package/generators/node-server/templates/server/src/management/api-docs.controller.ts.ejs

@@ -0,0 +1,27 @@
+import { Controller, Get, NotFoundException, UseGuards } from '@nestjs/common';
+import { ApiExcludeController, OpenAPIObject } from '@nestjs/swagger';
+
+import { AuthGuard, Roles, RolesGuard, RoleType } from '../auth/index.ts';
+import { ApiDocsService } from './api-docs.service.ts';
+
+/**
+ * The OpenAPI document of the api-docs profile at the path of springdoc, which the API page of the JHipster clients
+ * reads, for the administrators like JHipster Spring Boot.
+ */
+@ApiExcludeController()
+@Controller('v3')
+@UseGuards(AuthGuard, RolesGuard)
+@Roles(RoleType.ADMIN)
+export class ApiDocsController {
+  constructor(private readonly apiDocsService: ApiDocsService) {}
+
+  @Get('/api-docs')
+  apiDocs(): OpenAPIObject {
+    const document = this.apiDocsService.document;
+    if (!document) {
+      // Without the api-docs profile.
+      throw new NotFoundException();
+    }
+    return document;
+  }
+}

package/generators/node-server/templates/server/src/management/api-docs.service.ts.ejs

@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+import { OpenAPIObject } from '@nestjs/swagger';
+
+/** The OpenAPI document of the application, created by setupSwagger with the api-docs profile. */
+@Injectable()
+export class ApiDocsService {
+  document?: OpenAPIObject;
+}