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

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

@@ -0,0 +1,80 @@
+import { Controller, Get, UseGuards } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { ApiExcludeController } from '@nestjs/swagger';
+
+import { activeProfiles, config, configFiles } from '../config.ts';
+import { AuthGuard, Roles, RolesGuard, RoleType } from '../auth/index.ts';
+
+const MASK = '******';
+
+export interface PropertySource {
+  name: string;
+  properties: Record<string, { value: unknown }>;
+}
+
+export interface Env {
+  activeProfiles: string[];
+  propertySources: PropertySource[];
+}
+
+export interface ConfigProps {
+  contexts: Record<string, { beans: Record<string, { prefix: string; properties: Record<string, unknown> }> }>;
+}
+
+/**
+ * The env and configprops endpoints of Spring Boot Actuator the configuration page of the JHipster clients reads, for
+ * the administrators: the sources of the configuration (the environment variables, then the files of the active
+ * profiles and application.yml, the highest precedence first) and the properties of the application by prefix. Their
+ * values are shown as ****** unless management.endpoint.<endpoint>.show-values is always, like Spring Boot.
+ */
+@ApiExcludeController()
+@Controller('management')
+@UseGuards(AuthGuard, RolesGuard)
+@Roles(RoleType.ADMIN)
+export class ConfigurationController {
+  constructor(private readonly configService: ConfigService) {}
+
+  @Get('/env')
+  env(): Env {
+    const value = this.valueFor('env');
+    const source = (name: string, properties: Record<string, unknown>): PropertySource => ({
+      name,
+      properties: Object.fromEntries(Object.entries(properties).map(([key, property]) => [key, { value: value(property) }])),
+    });
+    return {
+      activeProfiles,
+      propertySources: [source('systemEnvironment', process.env), ...configFiles.map(({ name, properties }) => source(name, properties))],
+    };
+  }
+
+  @Get('/configprops')
+  configprops(): ConfigProps {
+    const value = this.valueFor('configprops');
+    const beans: ConfigProps['contexts'][string]['beans'] = {};
+    for (const [key, property] of Object.entries(config)) {
+      const separator = key.indexOf('.');
+      if (separator > 0 && typeof property !== 'function') {
+        const prefix = key.substring(0, separator);
+        beans[prefix] ??= { prefix, properties: {} };
+        setNested(beans[prefix].properties, key.substring(separator + 1).split('.'), value(property));
+      }
+    }
+    return { contexts: { [this.configService.get<string>('jhipster.clientApp.name') ?? 'application']: { beans } } };
+  }
+
+  private valueFor(endpoint: 'env' | 'configprops'): (property: unknown) => unknown {
+    const showValues = this.configService.get<string>(`management.endpoint.${endpoint}.show-values`) === 'always';
+    return property => (showValues ? property : MASK);
+  }
+}
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === 'object' && value !== null;
+
+function setNested(target: Record<string, unknown>, names: string[], value: unknown): void {
+  let parent = target;
+  for (const name of names.slice(0, -1)) {
+    const child = parent[name];
+    parent = parent[name] = isRecord(child) ? child : {};
+  }
+  parent[names[names.length - 1]] = value;
+}

package/generators/node-server/templates/server/src/management/health.controller.spec.ts.ejs

@@ -0,0 +1,79 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ServiceUnavailableException } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { Test, TestingModule } from '@nestjs/testing';
+import { HealthCheckService, TypeOrmHealthIndicator } from '@nestjs/terminus';
+import { SKIP_LOGGING } from '../common/interceptors/logging.interceptor.ts';
+import { HealthController } from './health.controller.ts';
+
+describe('Health Controller', () => {
+  let controller: HealthController;
+  const check = vi.fn<HealthCheckService['check']>();
+
+  beforeEach(async () => {
+    check.mockReset();
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [HealthController],
+      providers: [
+        { provide: HealthCheckService, useValue: { check } },
+        { provide: TypeOrmHealthIndicator, useValue: { pingCheck: vi.fn() } },
+      ],
+    }).compile();
+
+    controller = module.get<HealthController>(HealthController);
+  });
+
+  it('is UP when the database is up', async () => {
+    check.mockResolvedValue({ status: 'ok', info: { db: { status: 'up' } }, error: {}, details: { db: { status: 'up' } } });
+    const response = { status: vi.fn() };
+    await expect(controller.health(response as any)).resolves.toEqual({ status: 'UP', components: { db: { status: 'UP' } } });
+    expect(response.status).not.toHaveBeenCalled();
+  });
+
+  it('is DOWN with the status 503 when the database is down', async () => {
+    check.mockRejectedValue(
+      new ServiceUnavailableException({
+        status: 'error',
+        info: {},
+        error: { db: { status: 'down', message: 'connection refused' } },
+        details: { db: { status: 'down', message: 'connection refused' } },
+      }),
+    );
+    const response = { status: vi.fn() };
+    // The health of Spring Boot Actuator, not a problem detail: the health checks read it.
+    await expect(controller.health(response as any)).resolves.toEqual({ status: 'DOWN', components: { db: { status: 'DOWN' } } });
+    expect(response.status).toHaveBeenCalledWith(503);
+  });
+
+  it('the health checks are not logged', () => {
+    for (const name of ['health', 'liveness', 'readiness']) {
+      const method = Object.getOwnPropertyDescriptor(HealthController.prototype, name)?.value as () => unknown;
+      expect(new Reflector().get<boolean>(SKIP_LOGGING, method)).toBe(true);
+    }
+  });
+
+<%_ if (databaseTypeSql) { _%>
+  it('answers the liveness probe', () => {
+    expect(controller.liveness()).toEqual({ status: 'UP' });
+  });
+
+  it('is ready when the database is up, like the readiness group of JHipster Spring Boot', async () => {
+    check.mockResolvedValue({ status: 'ok', info: { db: { status: 'up' } }, error: {}, details: { db: { status: 'up' } } });
+    await expect(controller.readiness({ status: vi.fn() } as any)).resolves.toEqual({ status: 'UP' });
+  });
+
+  it('is not ready, with the status 503, when the database is down', async () => {
+    check.mockRejectedValue(
+      new ServiceUnavailableException({ status: 'error', info: {}, error: { db: { status: 'down' } }, details: { db: { status: 'down' } } }),
+    );
+    const response = { status: vi.fn() };
+    await expect(controller.readiness(response as any)).resolves.toEqual({ status: 'DOWN' });
+    expect(response.status).toHaveBeenCalledWith(503);
+  });
+<%_ } else { _%>
+  it('answers the liveness and readiness probes', () => {
+    expect(controller.liveness()).toEqual({ status: 'UP' });
+    expect(controller.readiness()).toEqual({ status: 'UP' });
+  });
+<%_ } _%>
+});

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

@@ -0,0 +1,87 @@
+import { Controller, Get, HttpStatus, Res, ServiceUnavailableException } from '@nestjs/common';
+import { ApiExcludeEndpoint } from '@nestjs/swagger';
+import { HealthCheckResult, HealthCheckService, TypeOrmHealthIndicator } from '@nestjs/terminus';
+import { Response } from 'express';
+
+import { SkipLogging } from '../common/interceptors/logging.interceptor.ts';
+
+export type HealthStatus = 'UP' | 'DOWN';
+
+export interface Health {
+  status: HealthStatus;
+  components: Record<string, { status: HealthStatus }>;
+}
+
+/**
+ * The health of the application in the format of Spring Boot Actuator: UP when every component (the database) is up,
+ * DOWN with the status 503 otherwise. Public and not logged, the container and service discovery health checks call it
+ * every few seconds.
+ */
+@Controller('management')
+export class HealthController {
+  constructor(
+    private readonly healthCheckService: HealthCheckService,
+    private readonly typeOrmHealthIndicator: TypeOrmHealthIndicator,
+  ) {}
+
+  @ApiExcludeEndpoint()
+  @Get('/health')
+  @SkipLogging()
+  async health(@Res({ passthrough: true }) response: Response): Promise<Health> {
+    try {
+      return toHealth(await this.healthCheckService.check([() => this.typeOrmHealthIndicator.pingCheck('db')]));
+    } catch (error) {
+      if (error instanceof ServiceUnavailableException) {
+        // The health of Spring Boot Actuator with the status 503, not a problem detail: the health checks read it.
+        response.status(HttpStatus.SERVICE_UNAVAILABLE);
+        return toHealth(error.getResponse() as HealthCheckResult);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * The liveness probe, like the liveness group of Spring Boot Actuator (livenessState): UP while the application answers.
+   */
+  @ApiExcludeEndpoint()
+  @Get('/health/liveness')
+  @SkipLogging()
+  liveness(): Pick<Health, 'status'> {
+    return { status: 'UP' };
+  }
+
+<%_ if (databaseTypeSql) { _%>
+  /**
+   * The readiness probe, like the readiness group of JHipster Spring Boot (readinessState,db): UP once the application
+   * accepts requests and reaches its database, DOWN with the status 503 otherwise. A JHipster gateway waits for it before
+   * routing to a microservice.
+   */
+  @ApiExcludeEndpoint()
+  @Get('/health/readiness')
+  @SkipLogging()
+  async readiness(@Res({ passthrough: true }) response: Response): Promise<Pick<Health, 'status'>> {
+    const { status } = await this.health(response);
+    return { status };
+  }
+<%_ } else { _%>
+  /**
+   * The readiness probe, like the readiness group of Spring Boot Actuator (readinessState): UP once the application
+   * accepts requests. A JHipster gateway waits for it before routing to a microservice.
+   */
+  @ApiExcludeEndpoint()
+  @Get('/health/readiness')
+  @SkipLogging()
+  readiness(): Pick<Health, 'status'> {
+    return { status: 'UP' };
+  }
+<%_ } _%>
+}
+
+function toHealth({ status, details }: HealthCheckResult): Health {
+  return {
+    status: status === 'ok' ? 'UP' : 'DOWN',
+    components: Object.fromEntries(
+      Object.entries(details).map(([name, { status }]) => [name, { status: status === 'up' ? 'UP' : 'DOWN' }]),
+    ),
+  };
+}

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

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { TerminusModule } from '@nestjs/terminus';
+import { HealthController } from './health.controller.ts';
+
+@Module({
+  imports: [TerminusModule],
+  controllers: [HealthController],
+})
+export class HealthModule {}

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

@@ -0,0 +1,40 @@
+import { BadRequestException, Body, Controller, Get, HttpCode, Param, Post, UseGuards } from '@nestjs/common';
+import { ApiExcludeController } from '@nestjs/swagger';
+
+import { LEVELS, Level, LoggerLevel, isLevel, loggerLevels } from '../common/logging.ts';
+import { AuthGuard, Roles, RolesGuard, RoleType } from '../auth/index.ts';
+
+export interface Loggers {
+  levels: readonly Level[];
+  loggers: Record<string, LoggerLevel>;
+}
+
+/**
+ * The loggers endpoint of Spring Boot Actuator, the logs page of the JHipster clients reads and changes: the level of
+ * each logger, changed while the application runs. For the administrators, like the management endpoints of JHipster.
+ */
+@ApiExcludeController()
+@Controller('management/loggers')
+@UseGuards(AuthGuard, RolesGuard)
+@Roles(RoleType.ADMIN)
+export class LoggersController {
+  @Get()
+  loggers(): Loggers {
+    return { levels: LEVELS, loggers: loggerLevels.getLevels() };
+  }
+
+  @Get('/:name')
+  logger(@Param('name') name: string): LoggerLevel {
+    return loggerLevels.getLevel(name);
+  }
+
+  /** Sets the level of a logger, a null `configuredLevel` gives it the level of its parent again. */
+  @Post('/:name')
+  @HttpCode(204)
+  setLevel(@Param('name') name: string, @Body() { configuredLevel }: { configuredLevel?: string | null }): void {
+    if (configuredLevel !== null && configuredLevel !== undefined && !isLevel(configuredLevel)) {
+      throw new BadRequestException(`Unknown level ${configuredLevel}, expected one of ${LEVELS.join(', ')}`);
+    }
+    loggerLevels.setLevel(name, configuredLevel ? (configuredLevel.toUpperCase() as Level) : null);
+  }
+}

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

@@ -0,0 +1,26 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { ConfigService } from '@nestjs/config';
+import { Test, TestingModule } from '@nestjs/testing';
+import { activeProfiles } from '../config.ts';
+import { ManagementController } from './management.controller.ts';
+
+describe('Management Controller', () => {
+  let controller: ManagementController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [ManagementController],
+      providers: [{ provide: ConfigService, useValue: new ConfigService({ info: { 'display-ribbon-on-profiles': 'dev,staging' } }) }],
+    }).compile();
+
+    controller = module.get<ManagementController>(ManagementController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+
+  it('info gives the active profiles and the profiles of the ribbon', () => {
+    expect(controller.info()).toEqual({ activeProfiles, 'display-ribbon-on-profiles': 'dev,staging' });
+  });
+});

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

@@ -0,0 +1,34 @@
+import { Controller, Get, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { ApiTags, ApiResponse, ApiOperation, ApiExcludeEndpoint } from '@nestjs/swagger';
+import { activeProfiles } from '../config.ts';
+
+/** The info of the info endpoint of Spring Boot Actuator the JHipster clients read: the profiles and the ribbon. */
+export interface Info {
+  activeProfiles: string[];
+  'display-ribbon-on-profiles': string;
+}
+
+@Controller('management')
+@ApiTags('management-controller')
+export class ManagementController {
+
+  logger = new Logger('ManagementController');
+
+  constructor(private readonly configService: ConfigService) {}
+
+  @ApiExcludeEndpoint()
+  @Get('/info')
+  @ApiOperation({ summary: 'Microservice Info' })
+  @ApiResponse({
+    status: 200,
+    description: 'Check if the microservice is up',
+  })
+  info(): Info {
+    return {
+      activeProfiles,
+      'display-ribbon-on-profiles': this.configService.getOrThrow<string>('info.display-ribbon-on-profiles'),
+    };
+  }
+
+}

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

@@ -0,0 +1,21 @@
+import { Module } from '@nestjs/common';
+import { APP_INTERCEPTOR } from '@nestjs/core';
+
+import { MetricsInterceptor, MetricsService } from '../common/metrics.ts';
+import { ApiDocsService } from './api-docs.service.ts';
+import { ApiDocsController } from './api-docs.controller.ts';
+import { ConfigurationController } from './configuration.controller.ts';
+import { LoggersController } from './loggers.controller.ts';
+import { MetricsController } from './metrics.controller.ts';
+
+/** The management endpoints of Spring Boot Actuator and the API documentation the admin pages of the JHipster clients use. */
+@Module({
+  controllers: [ApiDocsController, ConfigurationController, LoggersController, MetricsController],
+  providers: [
+    ApiDocsService,
+    MetricsService,
+    // Records the requests of every controller in the metrics.
+    { provide: APP_INTERCEPTOR, useClass: MetricsInterceptor },
+  ],
+})
+export class ManagementModule {}

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

@@ -0,0 +1,85 @@
+import { Controller, Get, Res, UseGuards } from '@nestjs/common';
+import { ApiExcludeController } from '@nestjs/swagger';
+import { Response } from 'express';
+import { isMainThread, threadId } from 'worker_threads';
+
+import { SkipLogging } from '../common/interceptors/logging.interceptor.ts';
+import { JHipsterMetrics, MetricsService } from '../common/metrics.ts';
+import { AuthGuard, Roles, RolesGuard, RoleType } from '../auth/index.ts';
+
+/** A thread of the threaddump endpoint of Spring Boot Actuator. */
+export interface Thread {
+  threadName: string;
+  threadId: number;
+  threadState: 'RUNNABLE';
+  daemon: boolean;
+  priority: number;
+  blockedTime: number;
+  blockedCount: number;
+  waitedTime: number;
+  waitedCount: number;
+  lockName: null;
+  lockOwnerId: number;
+  lockOwnerName: null;
+  inNative: boolean;
+  suspended: boolean;
+  stackTrace: [];
+  lockedMonitors: [];
+  lockedSynchronizers: [];
+  lockInfo: null;
+}
+
+/**
+ * The metrics endpoints of JHipster Spring Boot: jhimetrics and threaddump for the metrics page of the JHipster
+ * clients (administrators only), prometheus for the Prometheus of docker/prometheus (public, like JHipster).
+ */
+@ApiExcludeController()
+@Controller('management')
+export class MetricsController {
+  constructor(private readonly metricsService: MetricsService) {}
+
+  @Get('/jhimetrics')
+  @UseGuards(AuthGuard, RolesGuard)
+  @Roles(RoleType.ADMIN)
+  jhimetrics(): JHipsterMetrics {
+    return this.metricsService.jhipsterMetrics();
+  }
+
+  /** The thread running the JavaScript of the application: Node.js runs it on a single thread, its event loop. */
+  @Get('/threaddump')
+  @UseGuards(AuthGuard, RolesGuard)
+  @Roles(RoleType.ADMIN)
+  threaddump(): { threads: Thread[] } {
+    return {
+      threads: [
+        {
+          threadName: isMainThread ? 'main' : `worker-${threadId}`,
+          threadId,
+          threadState: 'RUNNABLE',
+          daemon: false,
+          priority: 5,
+          blockedTime: -1,
+          blockedCount: 0,
+          waitedTime: -1,
+          waitedCount: 0,
+          lockName: null,
+          lockOwnerId: -1,
+          lockOwnerName: null,
+          inNative: false,
+          suspended: false,
+          stackTrace: [],
+          lockedMonitors: [],
+          lockedSynchronizers: [],
+          lockInfo: null,
+        },
+      ],
+    };
+  }
+
+  @Get('/prometheus')
+  @SkipLogging()
+  async prometheus(@Res({ passthrough: true }) response: Response): Promise<string> {
+    response.type(this.metricsService.registry.contentType);
+    return this.metricsService.prometheus();
+  }
+}

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

@@ -0,0 +1,64 @@
+<%_ if (databaseTypeMongodb) { _%>
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class CreateTables1570200270081 implements MigrationInterface {
+  // synchronize() builds the schema with its own transaction (or its own connection),
+  // so the migration runner must not hold one around it
+  transaction = false;
+
+  public async up(queryRunner: QueryRunner): Promise<any> {
+    await queryRunner.dataSource.synchronize();
+  }
+
+  public async down(_queryRunner: QueryRunner): Promise<any> { }
+}
+<%_ } else { _%>
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+import { <% if (generateBuiltInUserEntity) { %>auditColumns, createJoinTable, <% } %>createTable } from './support/schema.ts';
+
+/**
+ * The tables of the built-in users and authorities, like the initial schema of JHipster Spring Boot. A database created by
+ * a former version of the application ran this migration already, its schema synchronized from the entities.
+ */
+export class CreateTables1570200270081 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+<%_ if (generateBuiltInAuthorityEntity) { _%>
+    await createTable(queryRunner, '<%= authority.entityTableName %>', [{ name: 'name', type: String, primary: true }]);
+<%_ } _%>
+<%_ if (generateBuiltInUserEntity) { _%>
+    await createTable(queryRunner, '<%= user.entityTableName %>', [
+      ...auditColumns(queryRunner),
+      { name: '<%= nodejsUserPrimaryKeyColumn.name %>', type: <%- nodejsUserPrimaryKeyColumn.type %>, primary: true, generated: '<%= nodejsUserPrimaryKeyColumn.generated %>' },
+      { name: 'login', type: String, unique: true },
+      { name: 'firstName', type: String, nullable: true },
+      { name: 'lastName', type: String, nullable: true },
+      { name: 'email', type: String, unique: true },
+      { name: 'activated', type: Boolean, default: false },
+      { name: 'langKey', type: String, default: 'en' },
+      { name: 'password', type: 'varchar'<% if (!generateUserManagement) { %>, nullable: true<% } %> },
+      { name: 'imageUrl', type: String, nullable: true },
+      { name: 'activationKey', type: String, nullable: true },
+      { name: 'resetKey', type: String, nullable: true },
+      { name: 'resetDate', type: Date, nullable: true },
+    ]);
+    await createJoinTable(
+      queryRunner,
+      '<%= nodejsUserAuthorityJoinTable.name %>',
+      { name: '<%= nodejsUserAuthorityJoinTable.joinColumn.name %>', type: <%- nodejsUserAuthorityJoinTable.joinColumn.type %>, referencedTableName: '<%= nodejsUserAuthorityJoinTable.joinColumn.referencedTableName %>', referencedColumnName: '<%= nodejsUserAuthorityJoinTable.joinColumn.referencedColumnName %>' },
+      { name: '<%= nodejsUserAuthorityJoinTable.inverseJoinColumn.name %>', type: <%- nodejsUserAuthorityJoinTable.inverseJoinColumn.type %>, referencedTableName: '<%= nodejsUserAuthorityJoinTable.inverseJoinColumn.referencedTableName %>', referencedColumnName: '<%= nodejsUserAuthorityJoinTable.inverseJoinColumn.referencedColumnName %>' },
+    );
+<%_ } _%>
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+<%_ if (generateBuiltInUserEntity) { _%>
+    await queryRunner.dropTable('<%= nodejsUserAuthorityJoinTable.name %>', true);
+    await queryRunner.dropTable('<%= user.entityTableName %>', true);
+<%_ } _%>
+<%_ if (generateBuiltInAuthorityEntity) { _%>
+    await queryRunner.dropTable('<%= authority.entityTableName %>', true);
+<%_ } _%>
+  }
+}
+<%_ } _%>

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

@@ -0,0 +1,26 @@
+import { type MigrationInterface, type QueryRunner, TableIndex } from 'typeorm';
+
+import { createTable } from './support/schema.ts';
+
+const SESSION_TABLE = '<%- jhiTablePrefix %>_session';
+
+/** The table of the sessions of the server (the Session entity), with the indices of its login and of its expiry. */
+export class CreateSessions1570200270082 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    if (await queryRunner.hasTable(SESSION_TABLE)) return;
+    await createTable(queryRunner, SESSION_TABLE, [
+      { name: 'sid', type: String, primary: true },
+      { name: 'login', type: String, nullable: true },
+      { name: 'expires', type: Date },
+      { name: 'data', type: 'text' },
+    ]);
+    const { namingStrategy } = queryRunner.connection;
+    for (const column of ['login', 'expires']) {
+      await queryRunner.createIndex(SESSION_TABLE, new TableIndex({ name: namingStrategy.indexName(SESSION_TABLE, [column]), columnNames: [column] }));
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropTable(SESSION_TABLE, true);
+  }
+}

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

@@ -0,0 +1,74 @@
+<%_ const UserEntity = user.persistClass %>
+import { MigrationInterface, QueryRunner } from 'typeorm';
+<%_ if (authenticationType !== 'oauth2') { _%>
+import { <%= UserEntity %> } from '../users/user.entity.ts';
+import { config } from '../config.ts';
+import { encodePassword } from '../auth/password-util.ts';
+<%_ } _%>
+import { Authority } from '../users/authority.entity.ts';
+
+export class SeedUsersRoles1570200490072 implements MigrationInterface {
+  role1: Authority = { name: 'ROLE_ADMIN' };
+
+  role2: Authority = { name: 'ROLE_USER' };
+
+  <%_ if (authenticationType !== 'oauth2') { _%>
+  // The users of JHipster Spring Boot: an administrator and a user, in the native language of the application.
+  user1: <%= UserEntity %> = {
+    login: 'admin',
+    password: 'admin',
+    firstName: 'Administrator',
+    lastName: 'Administrator',
+    email: 'admin@localhost',
+    imageUrl: '',
+    activated: true,
+    langKey: '<%= nativeLanguage %>',
+    createdBy: 'system',
+    lastModifiedBy: 'system'
+  };
+
+  user2: <%= UserEntity %> = {
+    login: 'user',
+    password: 'user',
+    firstName: 'User',
+    lastName: 'User',
+    email: 'user@localhost',
+    imageUrl: '',
+    activated: true,
+    langKey: '<%= nativeLanguage %>',
+    createdBy: 'system',
+    lastModifiedBy: 'system'
+  };
+
+  <%_ } _%>
+  public async up(queryRunner: QueryRunner): Promise<any> {
+
+    const authorityRepository = queryRunner.manager.getRepository("<%- jhiTablePrefix %>_authority");
+
+   <%_ if (authenticationType === 'oauth2') { _%>
+
+    await authorityRepository.save([this.role1, this.role2]);
+
+   <%_ } else { _%>
+
+    const adminRole = await authorityRepository.save(this.role1);
+    const userRole = await authorityRepository.save(this.role2);
+
+    const userRepository = queryRunner.manager.getRepository("<%- jhiTablePrefix %>_user");
+
+    this.user1.authorities= [adminRole, userRole];
+    this.user2.authorities= [userRole];
+
+    // The migrations run outside of the dependency injection: the rounds of the configuration, like the PasswordService.
+    const rounds = Number(config.get('<%= nodejsPasswordRoundsProperty %>'));
+    const users = await Promise.all(
+      [this.user1, this.user2].map(async user => ({ ...user, password: await encodePassword(user.password, rounds) })),
+    );
+
+    await userRepository.save(users);
+    <%_ } _%>
+  }
+
+
+  public async down(_queryRunner: QueryRunner): Promise<any> { }
+}