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

package/generators/node-server/templates/server/src/migrations/_entityConstraintsMigration_.ts.ejs

@@ -0,0 +1,40 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+import { <%= [nodejsConstraintsMigration.foreignKeys.length > 0 && 'createForeignKeys', nodejsConstraintsMigration.joinTables.length > 0 && 'createJoinTable'].filter(Boolean).join(', ') %> } from './support/schema.ts';
+
+/**
+ * Added the constraints of the entity <%= entityClass %>: its foreign keys and its join tables, after the tables they
+ * reference.
+ */
+export class <%= nodejsConstraintsMigration.className %> implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+<%_ if (nodejsConstraintsMigration.foreignKeys.length > 0) { _%>
+    await createForeignKeys(queryRunner, '<%= nodejsConstraintsMigration.tableName %>', [
+<%_ for (const foreignKey of nodejsConstraintsMigration.foreignKeys) { _%>
+      { columnName: '<%= foreignKey.columnName %>', referencedTableName: '<%= foreignKey.referencedTableName %>', referencedColumnName: '<%= foreignKey.referencedColumnName %>' },
+<%_ } _%>
+    ]);
+<%_ } _%>
+<%_ for (const joinTable of nodejsConstraintsMigration.joinTables) { _%>
+    await createJoinTable(
+      queryRunner,
+      '<%= joinTable.name %>',
+<%_ for (const column of [joinTable.joinColumn, joinTable.inverseJoinColumn]) { _%>
+      { name: '<%= column.name %>', type: <%- column.type %>, referencedTableName: '<%= column.referencedTableName %>', referencedColumnName: '<%= column.referencedColumnName %>' },
+<%_ } _%>
+    );
+<%_ } _%>
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+<%_ for (const joinTable of nodejsConstraintsMigration.joinTables) { _%>
+    await queryRunner.dropTable('<%= joinTable.name %>', true);
+<%_ } _%>
+<%_ if (nodejsConstraintsMigration.foreignKeys.length > 0) { _%>
+    const table = await queryRunner.getTable('<%= nodejsConstraintsMigration.tableName %>');
+    if (table) {
+      await queryRunner.dropForeignKeys(table, table.foreignKeys);
+    }
+<%_ } _%>
+  }
+}

package/generators/node-server/templates/server/src/migrations/_entityMigration_.ts.ejs

@@ -0,0 +1,26 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+import { auditColumns, createTable } from './support/schema.ts';
+
+/** Added the entity <%= entityClass %>. */
+export class <%= nodejsMigration.className %> implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await createTable(
+      queryRunner,
+      '<%= nodejsMigration.tableName %>',
+      [
+        ...auditColumns(queryRunner),
+<%_ for (const column of nodejsMigration.columns) { _%>
+        { name: '<%= column.name %>', type: <%- column.type %><% if (column.enum) { %>, enum: <%- column.enum %><% } %><% if (column.length) { %>, length: <%= column.length %><% } %><% if (column.precision) { %>, precision: <%= column.precision %>, scale: <%= column.scale %><% } %><% if (column.primary) { %>, primary: true, generated: '<%= column.generated %>'<% } %><% if (column.nullable) { %>, nullable: true<% } %><% if (column.unique) { %>, unique: true<% } %> },
+<%_ } _%>
+      ],
+<%_ if (nodejsMigration.relationUniques.length > 0) { _%>
+      { relationUniques: [<%- nodejsMigration.relationUniques.map(name => `'${name}'`).join(', ') %>] },
+<%_ } _%>
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropTable('<%= nodejsMigration.tableName %>', true);
+  }
+}

package/generators/node-server/templates/server/src/migrations/support/schema.ts.ejs

@@ -0,0 +1,202 @@
+import { type ColumnType, type QueryRunner, Table, type TableColumnOptions, TableForeignKey } from 'typeorm';
+import type { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata.js';
+
+import { databaseColumnType, databaseDatetimePrecision } from '../../common/database/column-types.ts';
+
+/**
+ * A column of a migration, with the options of the @Column decorator of its entity: the driver of the database gives its
+ * type, its length and its default like it does for the entity, so the table is the one the entity maps.
+ */
+export interface MigrationColumn {
+  name: string;
+  /** String, Number, Boolean, Date or a type of the database, like the type of the @Column decorator. */
+  type: ColumnType;
+  length?: number;
+  precision?: number;
+  scale?: number;
+  nullable?: boolean;
+  unique?: boolean;
+  default?: unknown;
+  onUpdate?: string;
+  primary?: boolean;
+  generated?: 'increment' | 'uuid';
+  enum?: string[];
+}
+
+/** A foreign key of a migration: the column of the table referencing the primary key of another table. */
+export interface MigrationForeignKey {
+  columnName: string;
+  referencedTableName: string;
+  referencedColumnName: string;
+  onDelete?: string;
+  onUpdate?: string;
+}
+
+const tableColumn = (queryRunner: QueryRunner, migrationColumn: MigrationColumn): TableColumnOptions => {
+  const { driver } = queryRunner.connection;
+  // The type and the precision of the database, like the ones the @Column decorators give (common/database/column-types.ts).
+  const instant = migrationColumn.type === Date && migrationColumn.precision === undefined;
+  const column = {
+    ...migrationColumn,
+    type: databaseColumnType(driver.options.type, migrationColumn.type),
+    ...(instant ? { precision: databaseDatetimePrecision(driver.options.type) } : {}),
+  };
+  // The properties of the column metadata the driver reads.
+  const metadata = {
+    ...column,
+    databaseName: column.name,
+    isArray: false,
+    isNullable: column.nullable ?? false,
+    isPrimary: column.primary ?? false,
+    isGenerated: !!column.generated,
+    generationStrategy: column.generated,
+  } as unknown as ColumnMetadata;
+  const type = driver.normalizeType(metadata);
+  // A uuid is a varchar(36) of MySQL, the column referencing one too, like TypeORM gives it to a join column.
+  const uuidLength = ['mysql', 'mariadb', 'aurora-mysql'].includes(driver.options.type) && column.type === 'uuid' && type !== 'uuid';
+  return {
+    name: column.name,
+    type,
+    length: uuidLength && !column.length ? '36' : driver.getColumnLength(metadata),
+    precision: column.precision,
+    scale: column.scale,
+    default: driver.normalizeDefault(metadata),
+    onUpdate: column.onUpdate,
+    isNullable: metadata.isNullable,
+    isPrimary: metadata.isPrimary,
+    isUnique: column.unique ?? false,
+    isGenerated: metadata.isGenerated,
+    generationStrategy: column.generated,
+    enum: column.enum,
+  };
+};
+
+/** The audit columns of the entities extending BaseEntity: createdBy, createdDate, lastModifiedBy, lastModifiedDate. */
+export const auditColumns = (queryRunner: QueryRunner): MigrationColumn[] => {
+  const { mappedDataTypes } = queryRunner.connection.driver;
+  return [
+    { name: 'createdBy', type: String, nullable: true },
+    {
+      name: 'createdDate',
+      type: mappedDataTypes.createDate,
+      precision: mappedDataTypes.createDatePrecision,
+      default: () => mappedDataTypes.createDateDefault,
+      nullable: true,
+    },
+    { name: 'lastModifiedBy', type: String, nullable: true },
+    {
+      name: 'lastModifiedDate',
+      type: mappedDataTypes.updateDate,
+      precision: mappedDataTypes.updateDatePrecision,
+      default: () => mappedDataTypes.updateDateDefault,
+      onUpdate: mappedDataTypes.updateDateDefault,
+      nullable: true,
+    },
+  ];
+};
+
+/**
+ * The databases storing the unique constraints as unique indices, like TypeORM does: the unique columns and the one-to-one
+ * join columns of MySQL and MariaDB, the one-to-one join columns of SQL Server (a filtered index, allowing several nulls).
+ */
+const uniqueIndexDatabases = ['mysql', 'mariadb', 'aurora-mysql', 'sap', 'spanner'];
+
+/**
+ * Creates a table, unless it exists: a database created by a former version of the application (its schema synchronized
+ * from the entities) has it already.
+ */
+export const createTable = async (
+  queryRunner: QueryRunner,
+  name: string,
+  columns: MigrationColumn[],
+  options: { relationUniques?: string[] } = {},
+): Promise<void> => {
+  const { driver, namingStrategy } = queryRunner.connection;
+  const uniqueIndices = uniqueIndexDatabases.includes(driver.options.type);
+  const relationUniqueIndices = uniqueIndices || driver.options.type === 'mssql';
+  // The unique constraint of the join column of a one-to-one relationship, named like TypeORM names it.
+  const relationUniques = (options.relationUniques ?? []).map(columnName => ({
+    name: namingStrategy.relationConstraintName(name, [columnName]),
+    columnNames: [columnName],
+  }));
+  await queryRunner.createTable(
+    new Table({
+      name,
+      columns: columns.map(column => tableColumn(queryRunner, { ...column, unique: column.unique && !uniqueIndices })),
+      uniques: relationUniqueIndices ? [] : relationUniques,
+      indices: [
+        ...(uniqueIndices ? columns.filter(column => column.unique).map(column => ({ columnNames: [column.name], isUnique: true })) : []),
+        ...(relationUniqueIndices
+          ? relationUniques.map(unique => ({
+              ...unique,
+              isUnique: true,
+              where: driver.options.type === 'mssql' ? `${driver.escape(unique.columnNames[0])} IS NOT NULL` : undefined,
+            }))
+          : []),
+      ],
+    }),
+    true,
+  );
+};
+
+/**
+ * Creates the foreign keys of a table missing in the database: a database created by a former version of the application
+ * has them already.
+ */
+export const createForeignKeys = async (queryRunner: QueryRunner, tableName: string, foreignKeys: MigrationForeignKey[]): Promise<void> => {
+  const table = await queryRunner.getTable(tableName);
+  if (!table) {
+    throw new Error(`The table ${tableName} does not exist`);
+  }
+  const missing = foreignKeys.filter(
+    foreignKey =>
+      !table.foreignKeys.some(existing => existing.columnNames.length === 1 && existing.columnNames[0] === foreignKey.columnName),
+  );
+  if (missing.length > 0) {
+    await queryRunner.createForeignKeys(
+      table,
+      missing.map(
+        ({ columnName, referencedTableName, referencedColumnName, onDelete, onUpdate }) =>
+          new TableForeignKey({
+            columnNames: [columnName],
+            referencedTableName,
+            referencedColumnNames: [referencedColumnName],
+            // The actions of the foreign keys of TypeORM, declared: the default of some databases differs (RESTRICT).
+            onDelete: onDelete ?? 'NO ACTION',
+            onUpdate: onUpdate ?? 'NO ACTION',
+          }),
+      ),
+    );
+  }
+};
+
+/**
+ * Creates the join table of a many-to-many relationship, with its indices and its foreign keys, unless it exists, like
+ * TypeORM creates the junction table of a @JoinTable.
+ */
+export const createJoinTable = async (
+  queryRunner: QueryRunner,
+  name: string,
+  joinColumn: MigrationColumn & { referencedTableName: string; referencedColumnName: string },
+  inverseJoinColumn: MigrationColumn & { referencedTableName: string; referencedColumnName: string },
+): Promise<void> => {
+  const exists = await queryRunner.hasTable(name);
+  if (exists) return;
+  const columns = [joinColumn, inverseJoinColumn];
+  await queryRunner.createTable(
+    new Table({
+      name,
+      columns: columns.map(({ referencedTableName: _table, referencedColumnName: _column, ...column }) =>
+        tableColumn(queryRunner, { ...column, primary: true }),
+      ),
+      indices: columns.map(column => ({ columnNames: [column.name] })),
+      foreignKeys: columns.map(column => ({
+        columnNames: [column.name],
+        referencedTableName: column.referencedTableName,
+        referencedColumnNames: [column.referencedColumnName],
+        onDelete: 'CASCADE',
+        onUpdate: 'CASCADE',
+      })),
+    }),
+  );
+};

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

@@ -0,0 +1,147 @@
+import { createRequire } from 'module';
+import { TypeOrmModuleOptions } from '@nestjs/typeorm';
+<%_ if (generateBuiltInAuthorityEntity) { _%>
+import { SeedUsersRoles1570200490072 } from './migrations/1570200490072-SeedUsersRoles.ts';
+<%_ } _%>
+<%_ if (databaseTypeMongodb || generateBuiltInUserEntity || generateBuiltInAuthorityEntity) { _%>
+import { CreateTables1570200270081 } from './migrations/1570200270081-CreateTables.ts';
+<%_ } _%>
+<%_ if (authenticationUsesCsrf && databaseTypeSql) { _%>
+import { CreateSessions1570200270082 } from './migrations/1570200270082-CreateSessions.ts';
+<%_ } _%>
+// jhipster-needle-add-entity-to-ormconfig-imports - JHipster will add code here, do not remove
+
+import { activeProfiles, config } from './config.ts';
+
+/** Reads a property of the configuration: ConfigService in the application, config outside of it (the typeorm CLI). */
+export type ConfigReader = (key: string) => any;
+
+// typeorm fails to auto load the drivers due to workspaces resolution: the driver of each database type, required when
+// its database is used.
+const require = createRequire(import.meta.url);
+<%_ if (prodDatabaseTypePostgresql) { _%>
+
+/**
+ * The pg driver keeping the instants in UTC, like the hibernate.jdbc.time_zone of JHipster Spring Boot: a timestamp
+ * (without time zone) is sent and read as UTC, not as the local time of the server.
+ */
+function pgDriver(): unknown {
+  const pg = require('pg');
+  pg.defaults.parseInputDatesAsUTC = true;
+  pg.types.setTypeParser(pg.types.builtins.TIMESTAMP, (value: string) => new Date(`${value.replace(' ', 'T')}Z`));
+  return pg;
+}
+<%_ } _%>
+const drivers: Record<string, () => unknown> = {
+<%_ if (databaseTypeSql) { _%>
+<%_ if (prodDatabaseTypePostgresql) { _%>
+  '<%= nodeProdDatabaseType %>': pgDriver,
+<%_ } else { _%>
+  '<%= nodeProdDatabaseType %>': () => require('<%= nodeProdDatabaseDriver %>'),
+<%_ } _%>
+  'better-sqlite3': () => require('better-sqlite3'),
+<%_ } else { _%>
+  mongodb: () => require('mongodb'),
+<%_ } _%>
+};
+<%_ if (databaseTypeMongodb) { _%>
+
+/**
+ * An in-memory MongoDB server, created again when another one took its port: mongodb-memory-server draws a free port and
+ * releases it before mongod listens on it, so the test files running in parallel can draw the same port.
+ */
+async function createMongoMemoryServer(
+  MongoMemoryServer: typeof import('mongodb-memory-server').MongoMemoryServer,
+  attempts = 3,
+): Promise<import('mongodb-memory-server').MongoMemoryServer> {
+  try {
+    return await MongoMemoryServer.create();
+  } catch (error) {
+    if (attempts > 1 && String(error).includes('already in use')) {
+      return createMongoMemoryServer(MongoMemoryServer, attempts - 1);
+    }
+    throw error;
+  }
+}
+<%_ } _%>
+
+/**
+ * The TypeORM options of the database of the active profiles: the database section of their application-{profile}.yml
+ * files, which environment variables override (DATABASE_HOST, DATABASE_PASSWORD, ...).
+ */
+<%_ if (databaseTypeMongodb) { _%>
+async function ormConfig(read: ConfigReader = key => config.get(key)): Promise<TypeOrmModuleOptions> {
+<%_ } else { _%>
+function ormConfig(read: ConfigReader = key => config.get(key)): TypeOrmModuleOptions {
+<%_ } _%>
+  const type = read('database.type');
+  const driver = drivers[type];
+  if (!driver) {
+    throw new Error(`The database.type '${type}' of the ${activeProfiles.join(',')} profiles is not supported`);
+  }
+  <%= databaseTypeMongodb ? 'let' : 'const' %> host = read('database.host');
+  <%= databaseTypeMongodb ? 'let' : 'const' %> port = read('database.port');
+  <%= databaseTypeMongodb ? 'let' : 'const' %> database = read('database.name');
+<%_ if (databaseTypeMongodb) { _%>
+  if (read('database.embedded')) {
+    // An in-memory MongoDB server, mongodb-memory-server is a dev dependency only loaded for it (test profile).
+    const { MongoMemoryServer } = await import('mongodb-memory-server');
+    const mongod = await createMongoMemoryServer(MongoMemoryServer);
+    host = '127.0.0.1';
+    port = mongod.instanceInfo?.port;
+    database = mongod.instanceInfo?.dbName;
+  }
+<%_ } _%>
+
+  return {
+    type,
+    driver: driver(),
+    host,
+    port,
+    username: read('database.username'),
+    password: read('database.password'),
+    database,
+<%_ if (prodDatabaseTypeMysql || prodDatabaseTypeMariadb) { _%>
+    // The instants in UTC, like the hibernate.jdbc.time_zone of JHipster Spring Boot (better-sqlite3 ignores it).
+    timezone: 'Z',
+<%_ } _%>
+    logging: read('database.logging') ?? false,
+    synchronize: read('database.synchronize') ?? false,
+    migrationsRun: true,
+<%_ if (databaseTypeMongodb) { _%>
+    // each migration runs in its own transaction, unless it sets transaction = false (CreateTables)
+<%_ } else { _%>
+    // each migration runs in its own transaction
+<%_ } _%>
+    migrationsTransactionMode: 'each',
+    entities: [
+      // jhipster-needle-add-entity-to-ormconfig-entities - JHipster will add code here, do not remove
+    ],
+    migrations: [
+<%_ if (databaseTypeMongodb || generateBuiltInUserEntity || generateBuiltInAuthorityEntity) { _%>
+      CreateTables1570200270081,
+<%_ } _%>
+<%_ if (authenticationUsesCsrf && databaseTypeSql) { _%>
+      CreateSessions1570200270082,
+<%_ } _%>
+<%_ if (generateBuiltInAuthorityEntity) { _%>
+      SeedUsersRoles1570200490072,
+<%_ } _%>
+      // jhipster-needle-add-migration-to-ormconfig-migrations - JHipster will add code here, do not remove
+    ],
+    autoLoadEntities: true,
+    // A bounded start: TypeORM tries to connect (and to run the migrations) 5 times, 3 seconds apart (10 times by default), then the start fails
+    // and the process exits, for the container orchestrator (docker compose, Kubernetes) to restart it.
+    retryAttempts: 5,
+    retryDelay: 3000,
+    // The retry logs tell the error of the connection.
+    verboseRetryLog: true,
+<%_ if (prodDatabaseTypeMssql) { _%>
+    extra: {
+      trustServerCertificate: true,
+    },
+<%_ } _%>
+  };
+}
+
+export { ormConfig };

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

@@ -0,0 +1,70 @@
+import { hostname } from 'os';
+
+import { BeforeApplicationShutdown, Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import Consul from 'consul';
+
+import type { ApplicationConfig } from '../application-config.ts';
+import { activeProfiles } from '../config.ts';
+
+/**
+ * The registration of the application in Consul, like Spring Cloud Consul: the service of cloud.consul.discovery with
+ * the HTTP health check of the application, registered once it listens and deregistered when it stops, so a gateway
+ * routes to it while it answers only.
+ */
+@Injectable()
+export class ConsulService implements BeforeApplicationShutdown {
+  private readonly logger = new Logger('ConsulService');
+
+  constructor(private readonly configService: ConfigService<ApplicationConfig, true>) {}
+  private consul?: Consul;
+  private serviceId?: string;
+
+  /** Registers the application listening on the port, when cloud.consul.enabled. */
+  async register(port: number): Promise<void> {
+    const { enabled, host, port: consulPort, discovery } = this.configService.get('cloud.consul', { infer: true });
+    if (!enabled) {
+      return;
+    }
+    const consul = new Consul({ host, port: Number(consulPort) });
+    const name = discovery['service-name'];
+    const id = discovery['instance-id'];
+    const address = discovery['prefer-ip-address'] ? this.configService.get('ipAddress', { infer: true }) || '127.0.0.1' : hostname();
+    this.logger.log(`Registering ${name} with Consul at ${host}:${consulPort}`);
+    try {
+      await consul.agent.service.register({
+        name,
+        id,
+        address,
+        port,
+        tags: [`profile=${activeProfiles.join(',')}`],
+        check: {
+          name: `Service '${name}' check`,
+          http: `http://${address}:${port}${discovery['health-check-path']}`,
+          interval: discovery['health-check-interval'],
+          timeout: discovery['health-check-timeout'],
+        },
+      });
+      this.consul = consul;
+      this.serviceId = id;
+      this.logger.log('Consul registration complete');
+    } catch (error) {
+      this.logger.error(`Consul registration failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  /** Deregisters the application before the server stops, so a gateway no longer routes to it. */
+  async beforeApplicationShutdown(): Promise<void> {
+    const { consul, serviceId } = this;
+    if (!consul || !serviceId) {
+      return;
+    }
+    this.consul = undefined;
+    try {
+      await consul.agent.service.deregister(serviceId);
+      this.logger.log('Consul deregistration complete');
+    } catch (error) {
+      this.logger.warn(`Consul deregistration failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}

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

@@ -0,0 +1,129 @@
+import { createRequire } from 'module';
+import { hostname } from 'os';
+
+import { BeforeApplicationShutdown, Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+
+import type { ApplicationConfig } from '../application-config.ts';
+import { isProfileActive } from '../config.ts';
+
+/** The client of eureka-js-client (the maintained fork of Rocket Software), which has no types. */
+interface EurekaClient {
+  start(callback: (error?: Error) => void): void;
+  stop(callback: (error?: Error) => void): void;
+  startHeartbeats(): void;
+  startRegistryFetches(): void;
+  on(event: 'registered', listener: () => void): void;
+  logger: { level(level: string): void };
+}
+
+/**
+ * The registration of the application in the Eureka server (the JHipster Registry), like Spring Cloud Netflix: at the
+ * eureka.client.service-url.defaultZone, once the application listens, with the intervals of the configuration, and
+ * cancelled when the application stops, so a gateway no longer routes to it.
+ */
+@Injectable()
+export class EurekaService implements BeforeApplicationShutdown {
+  private readonly logger = new Logger('EurekaService');
+
+  constructor(private readonly configService: ConfigService<ApplicationConfig, true>) {}
+  private client?: EurekaClient;
+
+  /** Registers the application listening on the port, when eureka.client.enabled. */
+  register(port: number): void {
+    if (!this.configService.get('eureka.client.enabled', { infer: true })) {
+      return;
+    }
+    const serviceUrl = new URL(this.configService.get('eureka.client.service-url.defaultZone', { infer: true }));
+    const appName = this.configService.get('eureka.instance.appname', { infer: true });
+    const ipAddress = this.configService.get('ipAddress', { infer: true }) || '127.0.0.1';
+    const hostName = this.configService.get('eureka.instance.prefer-ip-address', { infer: true }) ? ipAddress : hostname();
+    const baseUrl = `http://${hostName}:${port}`;
+    const leaseRenewalInterval = Number(this.configService.get('eureka.instance.lease-renewal-interval-in-seconds', { infer: true }));
+    const user = decodeURIComponent(serviceUrl.username) || this.configService.get('jhipster.registry.username', { infer: true }) || 'admin';
+    const password = decodeURIComponent(serviceUrl.password) || this.configService.get('jhipster.registry.password', { infer: true }) || 'admin';
+    const { Eureka } = createRequire(import.meta.url)('@rocketsoftware/eureka-js-client');
+    const client: EurekaClient = new Eureka({
+      instance: {
+        app: appName,
+        instanceId: this.configService.get('eureka.instance.instanceId', { infer: true }),
+        hostName,
+        ipAddr: ipAddress,
+        status: 'UP',
+        port: { $: port, '@enabled': 'true' },
+        // The service id Spring Cloud looks the instances up by (the routes of a JHipster gateway), like its spring.application.name.
+        vipAddress: appName,
+        homePageUrl: `${baseUrl}/`,
+        statusPageUrl: `${baseUrl}/management/info`,
+        healthCheckUrl: `${baseUrl}/management/health`,
+        leaseInfo: {
+          renewalIntervalInSecs: leaseRenewalInterval,
+          durationInSecs: Number(this.configService.get('eureka.instance.lease-expiration-duration-in-seconds', { infer: true })),
+        },
+        dataCenterInfo: {
+          '@class': 'com.netflix.appinfo.InstanceInfo$DefaultDataCenterInfo',
+          name: 'MyOwn',
+        },
+      },
+      eureka: {
+        host: serviceUrl.hostname,
+        port: Number(serviceUrl.port) || (serviceUrl.protocol === 'https:' ? 443 : 80),
+        ssl: serviceUrl.protocol === 'https:',
+        servicePath: `${serviceUrl.pathname.replace(/\/$/, '')}/apps/`,
+        heartbeatInterval: leaseRenewalInterval * 1000,
+        registryFetchInterval: Number(this.configService.get('eureka.client.registry-fetch-interval-seconds', { infer: true })) * 1000,
+        fetchRegistry: this.configService.get('eureka.client.fetch-registry', { infer: true }),
+        registerWithEureka: this.configService.get('eureka.client.register-with-eureka', { infer: true }),
+      },
+      requestMiddleware: (requestOpts: any, done: (requestOpts: any) => void): void => {
+        requestOpts.auth = { user, password };
+        done(requestOpts);
+      },
+    });
+    // The requests to the Eureka server are logged in development only.
+    client.logger.level(isProfileActive('dev') ? 'debug' : 'warn');
+    this.logger.log(`Registering ${appName} with Eureka at ${serviceUrl.host}`);
+    let registered = false;
+    client.on('registered', () => {
+      registered = true;
+    });
+    client.start(error => {
+      if (!error) {
+        this.logger.log('Eureka registration complete');
+        return;
+      }
+      if (registered || !this.configService.get('eureka.client.register-with-eureka', { infer: true })) {
+        // The first registry fetch failed: the next ones are at its interval.
+        this.logger.warn(`Eureka registry fetch failed: ${error.message}`);
+        return;
+      }
+      this.logger.error(`Eureka registration failed, retried at each heartbeat: ${error.message}`);
+      // Registered by the first heartbeat the server answers (404 for an unknown instance), like the Eureka client of Spring
+      // Cloud keeps on registering: eureka-js-client starts the heartbeats and the registry fetches once registered only.
+      client.startHeartbeats();
+      if (this.configService.get('eureka.client.fetch-registry', { infer: true })) {
+        client.startRegistryFetches();
+      }
+    });
+    this.client = client;
+  }
+
+  /** Cancels the registration before the server stops, so a gateway no longer routes to the application. */
+  beforeApplicationShutdown(): Promise<void> {
+    const { client } = this;
+    if (!client) {
+      return Promise.resolve();
+    }
+    this.client = undefined;
+    return new Promise(resolve => {
+      client.stop(error => {
+        if (error) {
+          this.logger.warn(`Eureka deregistration failed: ${error.message}`);
+        } else {
+          this.logger.log('Eureka deregistration complete');
+        }
+        resolve();
+      });
+    });
+  }
+}

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

@@ -0,0 +1,24 @@
+import { Logger, INestApplication } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';
+
+import { ApiDocsService } from './management/api-docs.service.ts';
+
+export function setupSwagger(app: INestApplication): any {
+
+  const logger: Logger = new Logger('Swagger');
+  const configService = app.get(ConfigService);
+
+  const options = new DocumentBuilder()
+    .setTitle(configService.getOrThrow<string>('jhipster.swagger.title'))
+    .setDescription(configService.getOrThrow<string>('jhipster.swagger.description'))
+    .setVersion(configService.getOrThrow<string>('jhipster.swagger.version'))
+    <%_ if (authenticationType === 'jwt') { _%>
+    .addBearerAuth()
+    <%_ } _%>
+    .build();
+  // Served by ApiDocsController at /v3/api-docs, the path of springdoc, for the administrators.
+  app.get(ApiDocsService).document = SwaggerModule.createDocument(app, options);
+  logger.log('Added the API documentation on /v3/api-docs');
+
+}

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

@@ -0,0 +1,27 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { HttpsOptions } from '@nestjs/common/interfaces/external/https-options.interface';
+import { config } from './config.ts';
+
+/**
+ * The HTTPS options of the server.ssl properties, like Spring Boot: the tls profile enables them (server.ssl.enabled)
+ * and the tls-samples profile adds the self-signed sample keystore. The keystore is a PKCS#12 file, a path relative to
+ * the working directory, or classpath:config/... for a file of the config folder (copied to dist with the yml files).
+ */
+export function httpsOptions(): HttpsOptions | undefined {
+  if (!config.get('server.ssl.enabled')) {
+    return undefined;
+  }
+  const keyStoreType = config.get('server.ssl.key-store-type');
+  if (keyStoreType !== 'PKCS12') {
+    throw new Error(`The server.ssl.key-store-type '${keyStoreType}' is not supported, use a PKCS12 keystore`);
+  }
+  const keyStore = config.get('server.ssl.key-store');
+  if (!keyStore) {
+    throw new Error('TLS is enabled without a keystore: set server.ssl.key-store, or activate the tls-samples profile in development');
+  }
+  return {
+    pfx: fs.readFileSync(keyStore.startsWith('classpath:') ? path.join(import.meta.dirname, keyStore.substring('classpath:'.length)) : keyStore),
+    passphrase: config.get('server.ssl.key-store-password'),
+  };
+}