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

package/generators/node-server/templates/server/src/common/database/pagination.entity.ts.ejs

@@ -0,0 +1,108 @@
+import { BadRequestException } from '@nestjs/common';
+import { Type, Expose as JsonProperty } from 'class-transformer';
+import type { ParsedQs } from 'qs';
+
+export type SortDirection = 'ASC' | 'DESC';
+
+export class Sort {
+  public property = 'id';
+  public direction: SortDirection = 'ASC';
+  constructor(sort?: string) {
+    if (sort) {
+      const [property, direction] = sort.split(',');
+      this.property = property.trim();
+      // Like Spring Data, the direction is case insensitive and ascending by default.
+      this.direction = direction?.trim().toUpperCase() === 'DESC' ? 'DESC' : 'ASC';
+    }
+  }
+
+  /** The TypeORM order of the property, nested for a property of a relationship like `region.name`. */
+  asOrder(): any {
+    return this.property
+      .split('.')
+      .reverse()
+      .reduce<any>((order, key) => ({ [key]: order }), this.direction);
+  }
+}
+
+export type PaginationQueryType = string | ParsedQs | (string | ParsedQs)[];
+
+export class PageRequest {
+  /** The maximum size of a page, the default of Spring Data. */
+  static readonly MAX_SIZE = 2000;
+
+  @JsonProperty()
+  page = 0;
+  @JsonProperty()
+  size = 20;
+  @Type(() => Sort)
+  sort: Sort[] = [new Sort('id,ASC')];
+
+  constructor(
+    page?: number | PaginationQueryType,
+    size?: number | PaginationQueryType
+    ,sort?: PaginationQueryType,
+    /**
+     * The properties a request can sort on: a list, like the allowed ordered properties of JHipster's UserResource, or a
+     * check of a property, any when not given.
+     */
+    sortProperties?: string[] | ((property: string) => boolean)
+  ) {
+    this.page = Math.max(PageRequest.handleNumberTypes(page, this.page), 0);
+    const requestedSize = PageRequest.handleNumberTypes(size, this.size);
+    this.size = requestedSize < 1 ? this.size : Math.min(requestedSize, PageRequest.MAX_SIZE);
+    const sorts = PageRequest.handleQueryTypes(sort).map(value => new Sort(value));
+    const isSortable = typeof sortProperties === 'function' ? sortProperties : (property: string): boolean => sortProperties?.includes(property) ?? true;
+    const invalid = sorts.find(each => !isSortable(each.property));
+    if (invalid) {
+      throw new BadRequestException(`Invalid sort property: ${invalid.property}`);
+    }
+    if (sorts.length > 0) {
+      this.sort = sorts;
+    }
+  }
+
+  /** The TypeORM order of every sort, in the order of the request, the properties of a relationship merged. */
+  asOrder(): any {
+    const order: any = {};
+    for (const { property, direction } of this.sort) {
+      const keys = property.split('.');
+      let target = order;
+      for (const key of keys.slice(0, -1)) {
+        target = target[key] ??= {};
+      }
+      target[keys[keys.length - 1]] = direction;
+    }
+    return order;
+  }
+
+  /** Every string of a query parameter given several times, like several `sort` parameters. */
+  public static handleQueryTypes(pa: PaginationQueryType | undefined): string[] {
+    return (Array.isArray(pa) ? pa : [pa]).filter((value): value is string => typeof value === 'string' && value.length > 0);
+  }
+
+  public static handleNumberTypes(pp: number | PaginationQueryType | undefined, fallback: number): number {
+    if (typeof pp === 'number') {
+      return pp;
+    }
+    const query = PageRequest.handleQueryType(pp);
+    if (query) {
+      const parsed = parseInt(query, 10);
+      return Number.isNaN(parsed) ? fallback : parsed;
+    }
+    return fallback;
+  }
+
+  public static handleQueryType(pa: PaginationQueryType | undefined): string | undefined {
+    pa = Array.isArray(pa) ? pa[0] : pa;
+    if (typeof pa === 'string') {
+      return pa;
+    }
+    return undefined;
+  }
+}
+
+/** A page of a list: its records (entities, or the users of the public user list), the total and the page request. */
+export class Page<T> {
+  constructor(public content: T[], public total: number, public pageable: PageRequest) {}
+}

package/generators/node-server/templates/server/src/common/dto/base.dto.ts.ejs

@@ -0,0 +1,19 @@
+/**
+ * A DTO base object.
+ */
+export class BaseDTO  {
+  createdBy?: string;
+
+  createdDate?: Date;
+
+  lastModifiedBy?: string;
+
+  lastModifiedDate?: Date;
+}
+
+/**
+ * The type of a relationship of a DTO, like the Relation of the TypeORM entities: two related DTOs import each other, and
+ * ES modules evaluate such a cycle one module at a time, so the decorator metadata of the property must not reference
+ * the other class (with this type it is Object), or the first module fails with "Cannot access ... before initialization".
+ */
+export type RelatedDTO<T> = T;

package/generators/node-server/templates/server/src/common/errors/error-constants.ts.ejs

@@ -0,0 +1,10 @@
+/** The problem types and the translation keys of the errors, like the ErrorConstants of JHipster Spring Boot. */
+export const ERR_VALIDATION = 'error.validation';
+export const PROBLEM_BASE_URL = 'https://www.jhipster.tech/problem';
+export const DEFAULT_TYPE = `${PROBLEM_BASE_URL}/problem-with-message`;
+export const CONSTRAINT_VIOLATION_TYPE = `${PROBLEM_BASE_URL}/constraint-violation`;
+<%_ if (generateUserManagement) { _%>
+export const INVALID_PASSWORD_TYPE = `${PROBLEM_BASE_URL}/invalid-password`;
+export const EMAIL_ALREADY_USED_TYPE = `${PROBLEM_BASE_URL}/email-already-used`;
+export const LOGIN_ALREADY_USED_TYPE = `${PROBLEM_BASE_URL}/login-already-used`;
+<%_ } _%>

package/generators/node-server/templates/server/src/common/errors/problem-details.filter.ts.ejs

@@ -0,0 +1,63 @@
+import { STATUS_CODES } from 'http';
+
+import { ArgumentsHost, Catch, ExceptionFilter, HttpException, HttpStatus, Logger } from '@nestjs/common';
+import { Request, Response } from 'express';
+
+import { HeaderUtil } from '../header-util.ts';
+
+import { DEFAULT_TYPE } from './error-constants.ts';
+import { BadRequestAlertException, ProblemException } from './problem.exception.ts';
+
+/**
+ * Answers the errors as the problem details (RFC 9457, application/problem+json) of JHipster Spring Boot, which the
+ * JHipster clients read: the type of the problem, the translation key of the error (message), the path of the request
+ * and the errors of the fields. An unexpected error is logged, and answered without its message.
+ */
+@Catch()
+export class ProblemDetailsFilter implements ExceptionFilter {
+  private readonly logger = new Logger('ProblemDetailsFilter');
+
+  constructor(private readonly headerUtil: HeaderUtil) {}
+
+  catch(exception: unknown, host: ArgumentsHost): void {
+    const http = host.switchToHttp();
+    const request = http.getRequest<Request>();
+    const response = http.getResponse<Response>();
+    const status = exception instanceof HttpException ? exception.getStatus() : HttpStatus.INTERNAL_SERVER_ERROR;
+    if (!(exception instanceof HttpException)) {
+      this.logger.error(`${request.method} ${request.originalUrl}`, exception instanceof Error ? exception.stack : String(exception));
+    }
+    if (response.headersSent) {
+      return;
+    }
+    if (exception instanceof BadRequestAlertException) {
+      // Like the ExceptionTranslator of JHipster Spring Boot, the alert headers the JHipster clients read first.
+      this.headerUtil.addFailureAlertHeaders(response, exception.entityName, exception.errorKey);
+    }
+    response
+      .status(status)
+      .type('application/problem+json')
+      .json({
+        type: DEFAULT_TYPE,
+        title: STATUS_CODES[status],
+        status,
+        detail: exception instanceof HttpException ? detailOf(exception) : undefined,
+        message: `error.http.${status}`,
+        path: request.path,
+        ...(exception instanceof ProblemException ? exception.problem : {}),
+      });
+  }
+}
+
+/** The message of an HttpException of Nest: the string it was created with, or the message of its response body. */
+const detailOf = (exception: HttpException): string | undefined => {
+  if (exception instanceof ProblemException) {
+    return exception.problem.detail;
+  }
+  const body = exception.getResponse();
+  if (typeof body === 'string') {
+    return body;
+  }
+  const { message } = body as { message?: string | string[] };
+  return Array.isArray(message) ? message.join(', ') : message;
+};

package/generators/node-server/templates/server/src/common/errors/problem.exception.ts.ejs

@@ -0,0 +1,92 @@
+import { HttpException, HttpStatus, ValidationError } from '@nestjs/common';
+
+import { CONSTRAINT_VIOLATION_TYPE, DEFAULT_TYPE, ERR_VALIDATION<% if (generateUserManagement) { %>, EMAIL_ALREADY_USED_TYPE, INVALID_PASSWORD_TYPE, LOGIN_ALREADY_USED_TYPE<% } %> } from './error-constants.ts';
+
+/** An error of a field, like the FieldErrorVM of JHipster Spring Boot. */
+export interface FieldErrorVM {
+  objectName: string;
+  field: string;
+  message: string;
+}
+
+/** The properties of a problem detail the exception gives, the others are completed by the ProblemDetailsFilter. */
+export interface ProblemProperties {
+  type?: string;
+  title?: string;
+  detail?: string;
+  /** The translation key of the error. */
+  message?: string;
+  /** The parameter of the translation, the entity name. */
+  params?: string;
+  fieldErrors?: FieldErrorVM[];
+}
+
+/** An exception answered as the problem detail it gives. */
+export class ProblemException extends HttpException {
+  constructor(
+    status: number,
+    readonly problem: ProblemProperties,
+  ) {
+    super(problem, status);
+  }
+}
+
+/**
+ * The errors of the validation of a request body, like the field errors of JHipster Spring Boot: the object (the class
+ * of the body without its <%= dtoSuffix %> suffix), the field and the message of the first constraint it fails.
+ */
+export const toFieldErrors = (errors: ValidationError[], parentPath = ''): FieldErrorVM[] =>
+  errors.flatMap(error => {
+    const field = `${parentPath}${error.property}`;
+    const objectName = (error.target?.constructor.name ?? '').replace(/^./, first => first.toLowerCase()).replace(/<%= dtoSuffix %>$/, '');
+    return [
+      ...Object.values(error.constraints ?? {})
+        .slice(0, 1)
+        .map(message => ({ objectName, field, message })),
+      ...toFieldErrors(error.children ?? [], `${field}.`),
+    ];
+  });
+
+/** The validation of a request body failed, like the MethodArgumentNotValidException of Spring. */
+export class ValidationException extends ProblemException {
+  constructor(errors: ValidationError[]) {
+    super(HttpStatus.BAD_REQUEST, {
+      type: CONSTRAINT_VIOLATION_TYPE,
+      title: 'Method argument not valid',
+      message: ERR_VALIDATION,
+      fieldErrors: toFieldErrors(errors),
+    });
+  }
+}
+
+/** A bad request of an entity, like the BadRequestAlertException of JHipster Spring Boot. */
+export class BadRequestAlertException extends ProblemException {
+  constructor(
+    defaultMessage: string,
+    readonly entityName: string,
+    readonly errorKey: string,
+    type = DEFAULT_TYPE,
+  ) {
+    super(HttpStatus.BAD_REQUEST, { type, title: defaultMessage, message: `error.${errorKey}`, params: entityName });
+  }
+}
+<%_ if (generateUserManagement) { _%>
+
+export class LoginAlreadyUsedException extends BadRequestAlertException {
+  constructor() {
+    super('Login name already used!', 'userManagement', 'userexists', LOGIN_ALREADY_USED_TYPE);
+  }
+}
+
+export class EmailAlreadyUsedException extends BadRequestAlertException {
+  constructor() {
+    super('Email is already in use!', 'userManagement', 'emailexists', EMAIL_ALREADY_USED_TYPE);
+  }
+}
+
+export class InvalidPasswordException extends ProblemException {
+  constructor() {
+    super(HttpStatus.BAD_REQUEST, { type: INVALID_PASSWORD_TYPE, title: 'Incorrect password' });
+  }
+}
+<%_ } _%>

package/generators/node-server/templates/server/src/common/field_validators.ejs

@@ -0,0 +1,77 @@
+<%#
+ Copyright 2019-2023 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+<%# Returns a string of all validator annotations for the entity field. -%>
+<%
+
+let result = '';
+const validators = [];
+
+if (field.fieldValidate === true) {
+    const rules = field.fieldValidateRules;
+    const MAX_VALUE = 2147483647;
+    // A required blob too: without a validator, the whitelist of the ValidationPipe strips it from the request.
+    if (rules.includes('required')) {
+        validators.push('@IsNotEmpty()');
+    } else if (!rules.includes('required')) {
+        // Like Bean Validation, the other rules accept a missing (null or undefined) value.
+        validators.push('@IsOptional()');
+    }
+    if (rules.includes('minlength') && !rules.includes('maxlength')) {
+        validators.push('@MinLength(' + field.fieldValidateRulesMinlength + ')');
+    }
+    if (rules.includes('maxlength') && !rules.includes('minlength')) {
+        validators.push('@MaxLength(' + field.fieldValidateRulesMaxlength + ')');
+    }
+    if (rules.includes('minlength') && rules.includes('maxlength')) {
+        validators.push('@Length(' + field.fieldValidateRulesMinlength + ', ' + field.fieldValidateRulesMaxlength + ')');
+    }
+    // Not supported anymore because the server can't check the size of the blob before downloading it completely.
+    // if (rules.includes('minbytes') && !rules.includes('maxbytes')) {
+    //     validators.push('@Size(min = ' + field.fieldValidateRulesMinbytes + ')');
+    // }
+    // if (rules.includes('maxbytes') && !rules.includes('minbytes')) {
+    //     validators.push('@Size(max = ' + field.fieldValidateRulesMaxbytes + ')');
+    // }
+    // if (rules.includes('minbytes') && rules.includes('maxbytes')) {
+    //     validators.push('@Size(min = ' + field.fieldValidateRulesMinbytes + ', max = ' + field.fieldValidateRulesMaxbytes + ')');
+    // }
+    if (rules.includes('min')) {
+        validators.push('@Min(' + field.fieldValidateRulesMin + ')');
+    }
+    if (rules.includes('max')) {
+        validators.push('@Max(' + field.fieldValidateRulesMax + ')');
+    }
+    if (rules.includes('pattern')) {
+        // Like Bean Validation @Pattern, the whole value matches the pattern.
+        validators.push('@Matches(' + JSON.stringify('^(?:' + field.fieldValidateRulesPattern + ')$') + ')');
+    }
+} else if (field.fieldIsEnum || field.nodejsTypeValidators.length > 0) {
+    validators.push('@IsOptional()');
+}
+// Like the JSON deserialization of JHipster Spring Boot, a value of another type is a bad request (400).
+validators.push(...field.nodejsTypeValidators);
+if (field.fieldIsEnum) {
+    // Like the JSON deserialization of JHipster Spring Boot, a value out of the enum is a bad request (400), not a database error.
+    validators.push('@IsEnum(' + field.fieldType + ')');
+}
+if (validators.length > 0) {
+    result = validators.join('\n    ');
+    result += '\n';
+} -%>
+<%- result -%>

package/generators/node-server/templates/server/src/common/header-util.ts.ejs

@@ -0,0 +1,105 @@
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { Response } from 'express';
+import { URL } from 'url';
+
+import type { ApplicationConfig } from '../application-config.ts';
+import { Page } from './database/pagination.entity.ts';
+
+/**
+ * The headers of the responses the JHipster clients read, like the HeaderUtil and the PaginationUtil of JHipster Spring
+ * Boot: the alerts, named after the application (jhipster.clientApp.name), and the pagination.
+ */
+@Injectable()
+export class HeaderUtil {
+  private readonly applicationName: string;
+
+  constructor(configService: ConfigService<ApplicationConfig, true>) {
+    this.applicationName = configService.get('jhipster.clientApp.name', { infer: true });
+  }
+
+  createAlert(res: Response, message: string, param: string): any {
+    res.set(`X-${this.applicationName}-alert`, message);
+    res.set(`X-${this.applicationName}-params`, param);
+  }
+
+  addEntityCreatedHeaders(res: Response, entityName: string, param: string | number | undefined): any {
+    res.status(201);
+<%_ if (enableTranslation) { _%>
+    // The translation key of the alert, translated by the client.
+    this.createAlert(res, `${this.applicationName}.${entityName}.created`, String(param));
+<%_ } else { _%>
+    this.createAlert(res, `A new ${entityName} is created with identifier ${param}`, String(param));
+<%_ } _%>
+  }
+
+  addEntityUpdatedHeaders(res: Response, entityName: string, param: string | number | undefined): any {
+    res.status(200);
+<%_ if (enableTranslation) { _%>
+    // The translation key of the alert, translated by the client.
+    this.createAlert(res, `${this.applicationName}.${entityName}.updated`, String(param));
+<%_ } else { _%>
+    this.createAlert(res, `A ${entityName} is updated with identifier ${param}`, String(param));
+<%_ } _%>
+  }
+
+  addEntityDeletedHeaders(res: Response, entityName: string, param: string | number | undefined): any {
+    res.status(204);
+<%_ if (enableTranslation) { _%>
+    // The translation key of the alert, translated by the client.
+    this.createAlert(res, `${this.applicationName}.${entityName}.deleted`, String(param));
+<%_ } else { _%>
+    this.createAlert(res, `A ${entityName} is deleted with identifier ${param}`, String(param));
+<%_ } _%>
+  }
+
+  /**
+   * The alerts of the user management, like the UserResource of JHipster Spring Boot: translated by the client from its
+   * userManagement keys.
+   */
+  addUserManagementHeaders(res: Response, action: 'created' | 'updated' | 'deleted', login: string): any {
+    res.status({ created: 201, updated: 200, deleted: 204 }[action]);
+<%_ if (enableTranslation) { _%>
+    this.createAlert(res, `userManagement.${action}`, login);
+<%_ } else { _%>
+    this.createAlert(res, `A user is ${action} with identifier ${login}`, login);
+<%_ } _%>
+  }
+
+  /**
+   * Like the failure alert of JHipster Spring Boot (BadRequestAlertException), the status comes from the thrown exception.
+   */
+  addFailureAlertHeaders(res: Response, entityName: string, errorKey: string): any {
+    res.set(`X-${this.applicationName}-error`, `error.${errorKey}`);
+    res.set(`X-${this.applicationName}-params`, entityName);
+  }
+
+  /**
+   * The pagination headers, like the PaginationUtil of JHipster Spring Boot: the total count of the elements, and the
+   * links of the next, previous, last and first pages.
+   */
+  addPaginationHeaders<T>(res: Response, page: Page<T>): any {
+    const url = res.req.url;
+    res.set('X-Total-Count', page.total.toString());
+    const pageNumber = page.pageable.page;
+    const pageSize = page.pageable.size;
+    const totalPages = Math.ceil(page.total / pageSize);
+    const links: string[] = [];
+    if (pageNumber < totalPages - 1) {
+      links.push(this.prepareLink(url, pageNumber + 1, pageSize, 'next'));
+    }
+    if (pageNumber > 0) {
+      links.push(this.prepareLink(url, pageNumber - 1, pageSize, 'prev'));
+    }
+    links.push(this.prepareLink(url, Math.max(totalPages - 1, 0), pageSize, 'last'));
+    links.push(this.prepareLink(url, 0, pageSize, 'first'));
+    res.set('Link', links.join(','));
+  }
+
+  private prepareLink(url: string, pageNumber: number, pageSize: number, relType: string): string {
+    const link = new URL(`http://localhost${url}`);
+    link.searchParams.set('page', String(pageNumber));
+    link.searchParams.set('size', String(pageSize));
+    return `<${link.toString().replace('http://localhost', '')}>; rel="${relType}"`;
+  }
+}

package/generators/node-server/templates/server/src/common/interceptors/logging.interceptor.spec.ts.ejs

@@ -0,0 +1,93 @@
+import { afterEach, beforeEach, describe, expect, it, type MockInstance, vi } from 'vitest';
+import { CallHandler, Controller, ExecutionContext, Get, Logger } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { EventEmitter } from 'events';
+import { of } from 'rxjs';
+import { LoggingInterceptor, SkipLogging } from './logging.interceptor.ts';
+
+@Controller('test')
+class TestController {
+  @Get('/logged')
+  logged(): string {
+    return 'logged';
+  }
+
+  @Get('/skipped')
+  @SkipLogging()
+  skipped(): string {
+    return 'skipped';
+  }
+}
+
+@Controller('skipped')
+@SkipLogging()
+class SkippedController {
+  @Get('/')
+  get(): string {
+    return 'skipped';
+  }
+}
+
+describe('LoggingInterceptor', () => {
+  const interceptor = new LoggingInterceptor(new Reflector());
+  const next: CallHandler = { handle: () => of('result') };
+  let response: EventEmitter & { statusCode: number };
+  let debug: MockInstance<Logger['debug']>;
+  let error: MockInstance<Logger['error']>;
+
+  const contextOf = (controller: any, handler: string): ExecutionContext =>
+    ({
+      getType: () => 'http',
+      getClass: () => controller,
+      getHandler: () => controller.prototype[handler],
+      switchToHttp: () => ({
+        getRequest: () => ({ method: 'GET', originalUrl: '/test/logged' }),
+        getResponse: () => response,
+      }),
+    }) as unknown as ExecutionContext;
+
+  beforeEach(() => {
+    response = Object.assign(new EventEmitter(), { statusCode: 200 });
+    debug = vi.spyOn(Logger.prototype, 'debug').mockImplementation(() => undefined);
+    error = vi.spyOn(Logger.prototype, 'error').mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('logs the method, URL, status and elapsed time once the response is sent', () => {
+    interceptor.intercept(contextOf(TestController, 'logged'), next);
+    expect(debug).not.toHaveBeenCalled();
+    response.emit('finish');
+    expect(debug).toHaveBeenCalledWith(expect.stringMatching(/^GET \/test\/logged 200 \d+ms - TestController\.logged\(\)$/));
+    expect(error).not.toHaveBeenCalled();
+  });
+
+  it('logs the client errors at the debug level', () => {
+    interceptor.intercept(contextOf(TestController, 'logged'), next);
+    response.statusCode = 404;
+    response.emit('finish');
+    expect(debug).toHaveBeenCalledWith(expect.stringMatching(/^GET \/test\/logged 404 \d+ms/));
+  });
+
+  it('logs the server errors at the error level', () => {
+    interceptor.intercept(contextOf(TestController, 'logged'), next);
+    response.statusCode = 500;
+    response.emit('finish');
+    expect(error).toHaveBeenCalledWith(expect.stringMatching(/^GET \/test\/logged 500 \d+ms/));
+    expect(debug).not.toHaveBeenCalled();
+  });
+
+  it('does not log a handler with @SkipLogging()', () => {
+    interceptor.intercept(contextOf(TestController, 'skipped'), next);
+    response.emit('finish');
+    expect(debug).not.toHaveBeenCalled();
+  });
+
+  it('does not log a controller with @SkipLogging()', () => {
+    interceptor.intercept(contextOf(SkippedController, 'get'), next);
+    response.emit('finish');
+    expect(debug).not.toHaveBeenCalled();
+  });
+});

package/generators/node-server/templates/server/src/common/interceptors/logging.interceptor.ts.ejs

@@ -0,0 +1,48 @@
+import { CallHandler, CustomDecorator, ExecutionContext, Injectable, Logger, NestInterceptor, SetMetadata } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { Observable } from 'rxjs';
+import { Request, Response } from 'express';
+
+export const SKIP_LOGGING = 'skipLogging';
+
+/**
+ * Excludes a controller, or one of its handlers, from the request logging of the LoggingInterceptor, like the health
+ * endpoint that the container and the service discovery health checks call every few seconds.
+ */
+export const SkipLogging = (): CustomDecorator<string> => SetMetadata(SKIP_LOGGING, true);
+
+/**
+ * Logs every request handled by a controller once its response is sent: method, URL, status and elapsed time.
+ * Registered globally in the AppModule (APP_INTERCEPTOR), opt out with @SkipLogging().
+ * Like the LoggingAspect of JHipster Spring Boot, the requests are logged at the debug level, the server errors (5xx) at the error level.
+ */
+@Injectable()
+export class LoggingInterceptor implements NestInterceptor {
+  private readonly logger = new Logger('LoggingInterceptor');
+
+  constructor(private readonly reflector: Reflector) {}
+
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    if (
+      context.getType() !== 'http' ||
+      this.reflector.getAllAndOverride<boolean>(SKIP_LOGGING, [context.getHandler(), context.getClass()])
+    ) {
+      return next.handle();
+    }
+    const request = context.switchToHttp().getRequest<Request>();
+    const response = context.switchToHttp().getResponse<Response>();
+    const handler = `${context.getClass().name}.${context.getHandler().name}()`;
+    const start = Date.now();
+    // Logged once the response is sent: the status of an exception is only set by the exception filters, after the
+    // interceptors, and the elapsed time includes the serialization of the response.
+    response.once('finish', () => {
+      const message = `${request.method} ${request.originalUrl} ${response.statusCode} ${Date.now() - start}ms - ${handler}`;
+      if (response.statusCode >= 500) {
+        this.logger.error(message);
+      } else {
+        this.logger.debug(message);
+      }
+    });
+    return next.handle();
+  }
+}