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

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

@@ -0,0 +1,83 @@
+import { describe, expect, it, vi } from 'vitest';
+import { LevelsConsoleLogger, LoggerLevels } from './logging.ts';
+
+describe('LoggerLevels', () => {
+  it('should give the ROOT level to the loggers without a level of their own', () => {
+    const levels = new LoggerLevels();
+    levels.configure({ 'logging.level.ROOT': 'warn' });
+
+    expect(levels.getLevel('AuthService')).toEqual({ configuredLevel: null, effectiveLevel: 'WARN' });
+    expect(levels.isEnabled('AuthService', 'warn')).toBe(true);
+    expect(levels.isEnabled('AuthService', 'log')).toBe(false);
+  });
+
+  it('should give a logger its level, else the one of its parent', () => {
+    const levels = new LoggerLevels();
+    levels.configure({ 'logging.level.ROOT': 'INFO', 'logging.level.app': 'DEBUG', 'logging.level.AuthService': 'ERROR' });
+
+    expect(levels.getLevel('AuthService').effectiveLevel).toBe('ERROR');
+    expect(levels.getLevel('app.service')).toEqual({ configuredLevel: null, effectiveLevel: 'DEBUG' });
+    expect(levels.isEnabled('app.service', 'debug')).toBe(true);
+    expect(levels.isEnabled('app.service', 'verbose')).toBe(false);
+  });
+
+  it('should list the ROOT logger first, then the known loggers by name', () => {
+    const levels = new LoggerLevels();
+    levels.isEnabled('UserService', 'log');
+    levels.setLevel('AuthService', 'DEBUG');
+
+    expect(Object.keys(levels.getLevels())).toEqual(['ROOT', 'AuthService', 'UserService']);
+  });
+
+  it('should give a logger the level of its parent again when its level is removed', () => {
+    const levels = new LoggerLevels();
+    levels.setLevel('AuthService', 'TRACE');
+    levels.setLevel('AuthService', null);
+    levels.setLevel('ROOT', null);
+
+    expect(levels.getLevel('AuthService')).toEqual({ configuredLevel: null, effectiveLevel: 'INFO' });
+    expect(levels.getLevel('ROOT').configuredLevel).toBe('INFO');
+  });
+
+  it('should print nothing for a logger OFF', () => {
+    const levels = new LoggerLevels();
+    levels.setLevel('Quiet', 'OFF');
+
+    expect(levels.isEnabled('Quiet', 'fatal')).toBe(false);
+  });
+});
+
+describe('LevelsConsoleLogger', () => {
+  it('should print the messages the level of their logger allows', () => {
+    const levels = new LoggerLevels();
+    levels.setLevel('Allowed', 'DEBUG');
+    const write = vi.spyOn(process.stdout, 'write').mockReturnValue(true);
+    try {
+      const logger = new LevelsConsoleLogger(levels);
+      logger.debug('printed', 'Allowed');
+      logger.debug('not printed', 'Other');
+      const printed = write.mock.calls.map(([chunk]) => String(chunk));
+      expect(printed.some(line => line.includes('printed') && line.includes('Allowed'))).toBe(true);
+      expect(printed.some(line => line.includes('not printed'))).toBe(false);
+    } finally {
+      write.mockRestore();
+    }
+  });
+
+  it('should print the stack trace of an error with its message only, not for a logger OFF', () => {
+    const levels = new LoggerLevels();
+    levels.setLevel('Silent', 'OFF');
+    const write = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
+    try {
+      const logger = new LevelsConsoleLogger(levels);
+      logger.error('silenced', 'Error: silenced\n    at silencedStack', 'Silent');
+      logger.error('failed', 'Error: failed\n    at printedStack', 'Printed');
+      const printed = write.mock.calls.map(([chunk]) => String(chunk)).join('');
+      expect(printed).not.toContain('silenced');
+      expect(printed).toContain('failed');
+      expect(printed).toContain('printedStack');
+    } finally {
+      write.mockRestore();
+    }
+  });
+});

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

@@ -0,0 +1,129 @@
+import { ConsoleLogger, LogLevel } from '@nestjs/common';
+
+/** The levels of Spring Boot, from the most to the least restrictive, as the loggers endpoint gives them. */
+export const LEVELS = ['OFF', 'ERROR', 'WARN', 'INFO', 'DEBUG', 'TRACE'] as const;
+
+export type Level = (typeof LEVELS)[number];
+
+/** The root logger, the level of the loggers without a level of their own, like the ROOT of Spring Boot. */
+export const ROOT = 'ROOT';
+
+/** The level of Spring Boot a log level of Nest needs to be printed. */
+const NEST_LEVELS: Record<LogLevel, Level> = {
+  fatal: 'ERROR',
+  error: 'ERROR',
+  warn: 'WARN',
+  log: 'INFO',
+  debug: 'DEBUG',
+  verbose: 'TRACE',
+};
+
+export interface LoggerLevel {
+  configuredLevel: Level | null;
+  effectiveLevel: Level;
+}
+
+export function isLevel(level: unknown): level is Level {
+  return typeof level === 'string' && (LEVELS as readonly string[]).includes(level.toUpperCase());
+}
+
+/**
+ * The levels of the loggers, like the logging system of Spring Boot: a logger is the context of a Nest logger, like
+ * `AuthService`, with the level of its own (`logging.level.AuthService`), else the one of its parent (`a.b` for
+ * `a.b.c`), else the one of the ROOT logger. The loggers endpoint reads and changes them while the application runs.
+ */
+export class LoggerLevels {
+  private readonly configured = new Map<string, Level>([[ROOT, 'INFO']]);
+
+  /** The loggers that printed something, listed by the loggers endpoint with the configured ones. */
+  private readonly known = new Set<string>([ROOT]);
+
+  /** Sets the levels of the `logging.level.<logger>` properties of the configuration. */
+  configure(properties: Record<string, unknown>): void {
+    for (const [key, value] of Object.entries(properties)) {
+      if (key.startsWith('logging.level.') && isLevel(value)) {
+        this.setLevel(key.substring('logging.level.'.length), value.toUpperCase() as Level);
+      }
+    }
+  }
+
+  /** Sets the level of a logger, or removes it with null (the ROOT logger keeps a level). */
+  setLevel(name: string, level: Level | null): void {
+    this.known.add(name);
+    if (level) {
+      this.configured.set(name, level);
+    } else if (name !== ROOT) {
+      this.configured.delete(name);
+    }
+  }
+
+  getLevel(name: string): LoggerLevel {
+    return { configuredLevel: this.configured.get(name) ?? null, effectiveLevel: this.effectiveLevel(name) };
+  }
+
+  /** Every known logger by name, the ROOT logger first then by name, like the loggers endpoint of Spring Boot. */
+  getLevels(): Record<string, LoggerLevel> {
+    const names = [...new Set([...this.known, ...this.configured.keys()])].sort((a, b) =>
+      a === ROOT ? -1 : b === ROOT ? 1 : a.localeCompare(b),
+    );
+    return Object.fromEntries(names.map(name => [name, this.getLevel(name)]));
+  }
+
+  isEnabled(name: string | undefined, logLevel: LogLevel): boolean {
+    const logger = name || ROOT;
+    this.known.add(logger);
+    return LEVELS.indexOf(NEST_LEVELS[logLevel]) <= LEVELS.indexOf(this.effectiveLevel(logger));
+  }
+
+  private effectiveLevel(name: string): Level {
+    for (let logger: string | undefined = name; logger; logger = parentOf(logger)) {
+      const level = this.configured.get(logger);
+      if (level) {
+        return level;
+      }
+    }
+    return this.configured.get(ROOT)!;
+  }
+}
+
+function parentOf(name: string): string | undefined {
+  const index = name.lastIndexOf('.');
+  return index > 0 ? name.substring(0, index) : undefined;
+}
+
+/** The levels of the loggers of the application. */
+export const loggerLevels = new LoggerLevels();
+
+/**
+ * The logger of the application: prints a message when the level of its logger allows it (loggerLevels), instead of the
+ * levels Nest applies to every logger.
+ */
+export class LevelsConsoleLogger extends ConsoleLogger {
+  /** Whether the messages of the last log were printed: the stack trace of an error is printed with them only. */
+  private printed = true;
+
+  constructor(private readonly levels: LoggerLevels = loggerLevels) {
+    super({ logLevels: ['verbose', 'debug', 'log', 'warn', 'error', 'fatal'] });
+  }
+
+  protected printMessages(
+    messages: unknown[],
+    context?: string,
+    logLevel: LogLevel = 'log',
+    writeStreamType?: 'stdout' | 'stderr',
+    errorStack?: unknown,
+    params?: Record<string, any>,
+  ): void {
+    this.printed = this.levels.isEnabled(context, logLevel);
+    if (this.printed) {
+      super.printMessages(messages, context, logLevel, writeStreamType, errorStack, params);
+    }
+  }
+
+  /** The stack trace of an error, which ConsoleLogger prints after its messages: not printed when they are not (OFF). */
+  protected printStackTrace(stack: string): void {
+    if (this.printed) {
+      super.printStackTrace(stack);
+    }
+  }
+}

package/generators/node-server/templates/server/src/common/metrics.spec.ts.ejs

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+import { MetricsService } from './metrics.ts';
+
+describe('MetricsService', () => {
+  it('should give the requests by status and by endpoint, like the jhimetrics endpoint', () => {
+    const metricsService = new MetricsService();
+    metricsService.recordRequest('GET', '/api/regions/:id', 200, 10);
+    metricsService.recordRequest('GET', '/api/regions/:id', 200, 30);
+    metricsService.recordRequest('POST', '/api/regions', 400, 5);
+
+    const metrics = metricsService.jhipsterMetrics();
+
+    expect(metrics['http.server.requests']).toEqual({
+      all: { count: 3 },
+      percode: { '200': { max: 30, mean: 20, count: 2 }, '400': { max: 5, mean: 5, count: 1 } },
+    });
+    expect(metrics.services).toEqual({
+      '/api/regions/:id': { GET: { max: 30, mean: 20, count: 2 } },
+      '/api/regions': { POST: { max: 5, mean: 5, count: 1 } },
+    });
+  });
+
+  it('should give the memory of the heap and the processor use', () => {
+    const metrics = new MetricsService().jhipsterMetrics();
+
+    expect(metrics.jvm.heap.used).toBeGreaterThan(0);
+    expect(metrics.jvm.heap.max).toBeGreaterThanOrEqual(metrics.jvm.heap.used);
+    expect(metrics.processMetrics['system.cpu.count']).toBeGreaterThan(0);
+    expect(metrics.processMetrics['process.cpu.usage']).toBeGreaterThanOrEqual(0);
+    expect(metrics.processMetrics['process.start.time']).toBeLessThanOrEqual(Date.now());
+  });
+
+  it('should give the requests in the format of Prometheus, like the timer of Micrometer', async () => {
+    const metricsService = new MetricsService();
+    metricsService.recordRequest('GET', '/api/regions', 200, 250);
+
+    const prometheus = await metricsService.prometheus();
+
+    expect(prometheus).toContain('http_server_requests_seconds_count{method="GET",uri="/api/regions",status="200",outcome="SUCCESS"} 1');
+    expect(prometheus).toContain('http_server_requests_seconds_max{method="GET",uri="/api/regions",status="200",outcome="SUCCESS"} 0.25');
+    expect(prometheus).toContain('process_cpu_user_seconds_total');
+  });
+});

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

@@ -0,0 +1,198 @@
+import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
+import { Request, Response } from 'express';
+import { availableParallelism, cpus, loadavg } from 'os';
+import { Gauge, Registry, Summary, collectDefaultMetrics } from 'prom-client';
+import { Observable } from 'rxjs';
+import { getHeapSpaceStatistics, getHeapStatistics } from 'v8';
+
+/** The max, mean and count of requests, in milliseconds, like the timers of the jhimetrics endpoint. */
+export interface MaxMeanCount {
+  max: number;
+  mean: number;
+  count: number;
+}
+
+export interface MemoryMetrics {
+  committed: number;
+  max: number;
+  used: number;
+}
+
+/**
+ * The metrics of the jhimetrics endpoint of JHipster Spring Boot the metrics page of the JHipster clients reads, for a
+ * Node.js process: the memory of its V8 heap and of each of its spaces instead of the JVM memory pools, its processor
+ * use, and the HTTP requests by status and by endpoint. Without the sections Node.js has no equivalent of (garbage
+ * collector, caches, connection pool), which the page shows only when present.
+ */
+export interface JHipsterMetrics {
+  jvm: Record<string, MemoryMetrics>;
+  'http.server.requests': { all: { count: number }; percode: Record<string, MaxMeanCount> };
+  services: Record<string, Record<string, MaxMeanCount>>;
+  processMetrics: {
+    'system.cpu.usage': number;
+    'system.cpu.count': number;
+    'system.load.average.1m': number;
+    'process.cpu.usage': number;
+    'process.start.time': number;
+    'process.uptime': number;
+  };
+}
+
+class Timer {
+  count = 0;
+  total = 0;
+  max = 0;
+
+  record(milliseconds: number): void {
+    this.count += 1;
+    this.total += milliseconds;
+    this.max = Math.max(this.max, milliseconds);
+  }
+
+  get maxMeanCount(): MaxMeanCount {
+    return { max: this.max, mean: this.count ? this.total / this.count : 0, count: this.count };
+  }
+}
+
+const timerOf = <K>(timers: Map<K, Timer>, key: K): Timer => {
+  let timer = timers.get(key);
+  if (!timer) {
+    timer = new Timer();
+    timers.set(key, timer);
+  }
+  return timer;
+};
+
+/**
+ * The metrics of the application: the default metrics of prom-client (process, Node.js) and the HTTP requests like
+ * the http.server.requests timer of Micrometer, given in the format of Prometheus by the prometheus endpoint and in the
+ * one of the jhimetrics endpoint.
+ */
+@Injectable()
+export class MetricsService {
+  readonly registry = new Registry();
+
+  private readonly requests: Summary<'method' | 'uri' | 'status' | 'outcome'>;
+
+  private readonly requestsMax: Gauge<'method' | 'uri' | 'status' | 'outcome'>;
+
+  private readonly byStatus = new Map<number, Timer>();
+
+  private readonly byService = new Map<string, Map<string, Timer>>();
+
+  private readonly maxByLabels = new Map<string, number>();
+
+  private lastCpu = { time: process.hrtime.bigint(), usage: process.cpuUsage(), system: cpuTimes() };
+
+  constructor() {
+    collectDefaultMetrics({ register: this.registry });
+    this.requests = new Summary({
+      name: 'http_server_requests_seconds',
+      help: 'Duration of the HTTP server requests',
+      labelNames: ['method', 'uri', 'status', 'outcome'],
+      percentiles: [],
+      registers: [this.registry],
+    });
+    this.requestsMax = new Gauge({
+      name: 'http_server_requests_seconds_max',
+      help: 'Maximum duration of the HTTP server requests',
+      labelNames: ['method', 'uri', 'status', 'outcome'],
+      registers: [this.registry],
+    });
+  }
+
+  /** Records a request by the path of its route, like `/api/regions/:id`, not by its URL. */
+  recordRequest(method: string, uri: string, status: number, milliseconds: number): void {
+    const labels = { method, uri, status: String(status), outcome: outcomeOf(status) };
+    this.requests.observe(labels, milliseconds / 1000);
+    const labelsKey = `${method} ${uri} ${status}`;
+    const max = Math.max(this.maxByLabels.get(labelsKey) ?? 0, milliseconds);
+    this.maxByLabels.set(labelsKey, max);
+    this.requestsMax.set(labels, max / 1000);
+    timerOf(this.byStatus, status).record(milliseconds);
+    const serviceTimers = this.byService.get(uri) ?? new Map<string, Timer>();
+    this.byService.set(uri, serviceTimers);
+    timerOf(serviceTimers, method).record(milliseconds);
+  }
+
+  async prometheus(): Promise<string> {
+    return this.registry.metrics();
+  }
+
+  jhipsterMetrics(): JHipsterMetrics {
+    const heap = getHeapStatistics();
+    const jvm: Record<string, MemoryMetrics> = {
+      heap: { used: heap.used_heap_size, committed: heap.total_heap_size, max: heap.heap_size_limit },
+    };
+    // The spaces of the heap, without the ones V8 does not use (nothing reserved and nothing available).
+    for (const space of getHeapSpaceStatistics().filter(space => space.space_size > 0 || space.space_available_size > 0)) {
+      jvm[space.space_name] = {
+        used: space.space_used_size,
+        committed: space.space_size,
+        max: space.space_size + space.space_available_size,
+      };
+    }
+    const percode = Object.fromEntries([...this.byStatus].map(([status, timer]) => [String(status), timer.maxMeanCount]));
+    const services = Object.fromEntries(
+      [...this.byService].map(([uri, timers]) => [uri, Object.fromEntries([...timers].map(([method, timer]) => [method, timer.maxMeanCount]))]),
+    );
+    return {
+      jvm,
+      'http.server.requests': { all: { count: [...this.byStatus.values()].reduce((count, timer) => count + timer.count, 0) }, percode },
+      services,
+      processMetrics: { ...this.cpuUsage(), 'process.start.time': Date.now() - process.uptime() * 1000, 'process.uptime': process.uptime() * 1000 },
+    };
+  }
+
+  /** The processor use of the process and of the system since the previous call, between 0 and 1. */
+  private cpuUsage(): Pick<JHipsterMetrics['processMetrics'], 'system.cpu.usage' | 'system.cpu.count' | 'system.load.average.1m' | 'process.cpu.usage'> {
+    const now = { time: process.hrtime.bigint(), usage: process.cpuUsage(), system: cpuTimes() };
+    const count = availableParallelism();
+    const elapsedMicroseconds = Number(now.time - this.lastCpu.time) / 1000;
+    const processMicroseconds = now.usage.user - this.lastCpu.usage.user + now.usage.system - this.lastCpu.usage.system;
+    const systemTotal = now.system.total - this.lastCpu.system.total;
+    const systemIdle = now.system.idle - this.lastCpu.system.idle;
+    this.lastCpu = now;
+    return {
+      'system.cpu.usage': systemTotal > 0 ? (systemTotal - systemIdle) / systemTotal : 0,
+      'system.cpu.count': count,
+      'system.load.average.1m': loadavg()[0],
+      'process.cpu.usage': elapsedMicroseconds > 0 ? Math.min(1, processMicroseconds / elapsedMicroseconds / count) : 0,
+    };
+  }
+}
+
+function cpuTimes(): { total: number; idle: number } {
+  return cpus().reduce(
+    (times, { times: { user, nice, sys, idle, irq } }) => ({ total: times.total + user + nice + sys + idle + irq, idle: times.idle + idle }),
+    { total: 0, idle: 0 },
+  );
+}
+
+function outcomeOf(status: number): string {
+  if (status < 200) return 'INFORMATIONAL';
+  if (status < 300) return 'SUCCESS';
+  if (status < 400) return 'REDIRECTION';
+  return status < 500 ? 'CLIENT_ERROR' : 'SERVER_ERROR';
+}
+
+/** Records every request handled by a controller in the MetricsService, once its response is sent. */
+@Injectable()
+export class MetricsInterceptor implements NestInterceptor {
+  constructor(private readonly metricsService: MetricsService) {}
+
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    if (context.getType() !== 'http') {
+      return next.handle();
+    }
+    const request = context.switchToHttp().getRequest<Request>();
+    const response = context.switchToHttp().getResponse<Response>();
+    const start = process.hrtime.bigint();
+    // Recorded once the response is sent, with the status the exception filters set.
+    response.once('finish', () => {
+      const uri: string = request.route?.path ?? 'UNKNOWN';
+      this.metricsService.recordRequest(request.method, uri, response.statusCode, Number(process.hrtime.bigint() - start) / 1e6);
+    });
+    return next.handle();
+  }
+}

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

@@ -0,0 +1,8 @@
+import { Request as ExpressRequest, Response } from 'express';
+import { <%= userLoginVmClass%> } from '../users/dto/user.dto.ts';
+
+export interface Request extends ExpressRequest {
+  user?: <%= userLoginVmClass%>;
+  // Express always sets the response of a request
+  res: Response;
+}

package/generators/node-server/templates/server/src/common/sortable-properties.ts.ejs

@@ -0,0 +1,43 @@
+import { EntityMetadata<% if (databaseTypeMongodb) { %>, FindOptionsOrder<% } %> } from 'typeorm';
+
+export interface SortableOptions {
+  /** Columns of the entity no list can be sorted on, like the password of a user. */
+  unsortable?: string[];
+  /** The label of each relationship, the field of the other entity a list of the entity displays, like `name`. */
+  labels?: Record<string, string>;
+}
+
+/**
+ * Whether a list of the entity can be sorted on a property, found by introspection of its TypeORM metadata like Spring
+ * Data validates the sort of a pageable: a column of the entity, or, for a relationship to one it owns, the id or the label of
+ * the other entity (`region.id`, `region.name`). A relationship itself, a collection, another column of the other
+ * entity or a deeper path cannot be sorted on.
+ */
+export function isSortableProperty(metadata: EntityMetadata, property: string, { unsortable = [], labels = {} }: SortableOptions = {}): boolean {
+  const [name, otherProperty, ...deeper] = property.split('.');
+  const relation = metadata.findRelationWithPropertyPath(name);
+  if (otherProperty === undefined) {
+    return relation === undefined && !unsortable.includes(name) && metadata.findColumnWithPropertyPath(name) !== undefined;
+  }
+  if (relation === undefined || !relation.isOwning || relation.isOneToMany || relation.isManyToMany || deeper.length > 0) {
+    return false;
+  }
+  const otherMetadata = relation.inverseEntityMetadata;
+  const isId = otherMetadata.primaryColumns.some(column => column.propertyName === otherProperty);
+  return (isId || labels[name] === otherProperty) && otherMetadata.findColumnWithPropertyPath(otherProperty) !== undefined;
+}
+<%_ if (databaseTypeMongodb) { _%>
+
+/**
+ * The order of a MongoDB query by the names of the fields of the documents: TypeORM sorts a MongoDB query by the keys of
+ * the order as given, the names of the properties, and the id of a document is its _id.
+ */
+export function documentOrder<T>(metadata: EntityMetadata, order?: FindOptionsOrder<T>): FindOptionsOrder<T> | undefined {
+  return (
+    order &&
+    (Object.fromEntries(
+      Object.entries(order).map(([property, direction]) => [metadata.findColumnWithPropertyPath(property)?.databaseName ?? property, direction]),
+    ) as FindOptionsOrder<T>)
+  );
+}
+<%_ } _%>

package/generators/node-server/templates/server/src/common/updatable-properties.ts.ejs

@@ -0,0 +1,14 @@
+import { EntityMetadata, ObjectLiteral, QueryDeepPartialEntity } from 'typeorm';
+
+/**
+ * The properties of an entity an update may write: every property but the columns declared with `update: false`, like
+ * the creation audit fields. The MongoDB driver of TypeORM ignores the update: false option and would write those
+ * columns.
+ */
+export function updatableProperties<Entity extends ObjectLiteral>(metadata: EntityMetadata, entity: Entity): QueryDeepPartialEntity<Entity> {
+  const properties: ObjectLiteral = { ...entity };
+  for (const column of metadata.columns.filter(column => !column.isUpdate)) {
+    delete properties[column.propertyName];
+  }
+  return properties as QueryDeepPartialEntity<Entity>;
+}

package/generators/node-server/templates/server/src/config/application-dev.yml.ejs

@@ -0,0 +1,118 @@
+# ===================================================================
+# Configuration for the "dev" profile.
+#
+# This configuration overrides the application.yml file.
+#
+# More information on profiles: https://www.jhipster.tech/profiles/
+# More information on configuration properties: https://www.jhipster.tech/common-application-properties/
+# ===================================================================
+
+# ===================================================================
+# Standard app properties.
+# ===================================================================
+
+<%_ if (serviceDiscoveryEureka) { _%>
+eureka:
+  instance:
+    prefer-ip-address: true
+  client:
+    service-url:
+      defaultZone: http://admin:${jhipster.registry.password}@localhost:8761/eureka/
+
+<%_ } _%>
+<%_ if (serviceDiscoveryConsul) { _%>
+cloud:
+  consul:
+    discovery:
+      prefer-ip-address: true
+
+<%_ } _%>
+# The level of the loggers, like Spring Boot: ROOT for the loggers without a level of their own, a logger by the
+# context of its Nest logger (like AuthService: DEBUG). The logs page of the client changes them while it runs.
+logging:
+  level:
+    ROOT: DEBUG
+
+server:
+  port: <%= serverPort %>
+  # make sure requests the proxy uri instead of the server one, like JHipster Spring Boot (the proxies of the local networks)
+  forward-headers-strategy: native
+
+# ===================================================================
+# JHipster specific properties
+#
+# Full reference is available at: https://www.jhipster.tech/common-application-properties/
+# ===================================================================
+
+# The database, read by orm.config.ts (TypeORM options): environment variables override each property, like
+# DATABASE_HOST or DATABASE_PASSWORD.
+database:
+<%_ if (nodeDevDatabaseType === 'better-sqlite3') { _%>
+  # SQLite, the embedded database of development like H2 in a Spring Boot application.
+  type: better-sqlite3
+  name: '<%- nodeDevSqliteDatabase %>'
+  logging: true
+<%_ } else { _%>
+  # The database of docker/<%= databaseTypeSql ? prodDatabaseType : 'mongodb' %>.yml (npm run docker:db:up).
+  type: <%= nodeDevDatabaseType %>
+  host: 127.0.0.1
+  port: <%= nodeDatabasePort %>
+<%_ if (databaseTypeSql) { _%>
+  username: <%- devDatabaseUsername %>
+  password: '<%- devDatabasePassword %>'
+  name: <%- devDatabaseName %>
+<%_ } else { _%>
+  name: <%= baseName %>
+<%_ } _%>
+  logging: false
+<%_ } _%>
+
+<%_ if (generateUserManagement) { _%>
+# The SMTP server of the account mails (activation, creation, password reset), read by the mail module
+# (@nestjs-modules/mailer), like spring.mail of JHipster Spring Boot: environment variables override each property, like MAIL_HOST
+# or MAIL_PASSWORD.
+mail:
+  host: localhost
+  port: 25
+  username:
+  password:
+
+<%_ } _%>
+jhipster:
+<%_ if (applicationTypeMicroservice) { _%>
+  # CORS is disabled by default on microservices, as you should access them through a gateway.
+  # If you want to enable it, please uncomment the configuration below.
+  # cors:
+  #   allowed-origins: "http://localhost:9000,https://localhost:9000"
+  #   allowed-methods: "*"
+  #   allowed-headers: "*"
+  #   exposed-headers: "Authorization,Link,X-Total-Count,X-${jhipster.clientApp.name}-alert,X-${jhipster.clientApp.name}-error,X-${jhipster.clientApp.name}-params"
+  #   allow-credentials: true
+  #   max-age: 1800
+<%_ } else { _%>
+  # CORS is only enabled by default with the "dev" profile, like JHipster Spring Boot.
+  cors:
+    # Allow Ionic for JHipster by default
+    allowed-origins: "http://localhost:8100,https://localhost:8100<% if (devServerPortProxy) { %>,http://localhost:<%- devServerPortProxy %>,https://localhost:<%- devServerPortProxy %><% } %><% if (!skipClient) { %>,http://localhost:<%- devServerPort %>,https://localhost:<%- devServerPort %><% } %>"
+    # Enable CORS when running in GitHub Codespaces
+    allowed-origin-patterns: 'https://*.githubpreview.dev'
+    allowed-methods: "*"
+    allowed-headers: "*"
+    exposed-headers: "Authorization,Link,X-Total-Count,X-${jhipster.clientApp.name}-alert,X-${jhipster.clientApp.name}-error,X-${jhipster.clientApp.name}-params"
+    allow-credentials: true
+    max-age: 1800
+<%_ } _%>
+  mail: # specific JHipster mail property, for standard properties see MailProperties
+    from: <%= baseName %>@localhost
+    base-url: http://127.0.0.1:<%= serverPort %>
+
+# ===================================================================
+# Application specific properties
+# Add your own application properties here, see the ApplicationProperties class
+# to have type-safe configuration, like in the JHipsterProperties above
+#
+# More documentation is available at:
+# https://www.jhipster.tech/common-application-properties/
+# ===================================================================
+
+# application: