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

package/generators/node-server/templates/server/src/auth/session.store.ts.ejs

@@ -0,0 +1,116 @@
+import { Injectable, Logger, OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import session from 'express-session';
+import { <% if (databaseTypeSql) { %>LessThan, <% } %>Repository } from 'typeorm';
+import { Session } from './session.entity.ts';
+import { SESSION_MAX_AGE } from './csrf.middleware.ts';
+
+/** The interval of the removal of the expired sessions. */
+export const PRUNE_INTERVAL = 60 * 60 * 1000;
+
+type Callback<T = unknown> = (error?: any, value?: T) => void;
+
+/** A session of a user, its id and its data. */
+export interface StoredSession {
+  sid: string;
+  data: session.SessionData & Record<string, any>;
+}
+
+/**
+ * The sessions of the server in the database of the application, the store of express-session: a session outlives a
+ * restart of the application and is shared by its instances, unlike the MemoryStore of express-session, and the expired
+ * sessions are removed every hour. The application closes after the operations in progress: express-session ends a
+ * response in the callback of its touch, after the client has the whole response.
+ */
+@Injectable()
+export class SessionStore extends session.Store implements OnModuleInit, OnModuleDestroy {
+  private readonly logger = new Logger('SessionStore');
+  private pruneTimer?: NodeJS.Timeout;
+  /** The operations in progress on the database, waited for before the database is closed. */
+  private readonly pending = new Set<Promise<unknown>>();
+
+  constructor(@InjectRepository(Session) private readonly repository: Repository<Session>) {
+    super();
+  }
+
+  onModuleInit(): void {
+    this.pruneTimer = setInterval(() => {
+      this.prune().catch((error: Error) => this.logger.warn(`The expired sessions could not be removed: ${error.message}`));
+    }, PRUNE_INTERVAL);
+    // The removal does not keep the process alive.
+    this.pruneTimer.unref();
+  }
+
+  /** Before TypeORM closes the database (onApplicationShutdown): the operations in progress end first. */
+  async onModuleDestroy(): Promise<void> {
+    clearInterval(this.pruneTimer);
+    await Promise.allSettled([...this.pending]);
+  }
+
+  get(sid: string, callback: Callback<session.SessionData | null>): void {
+    this.track(this.repository.findOne({ where: { sid } })).then(
+      found => callback(null, found && found.expires.getTime() > Date.now() ? JSON.parse(found.data) : null),
+      callback,
+    );
+  }
+
+  set(sid: string, data: session.SessionData, callback?: Callback): void {
+    this.track(this.save(sid, data)).then(() => callback?.(), error => callback?.(error));
+  }
+
+  touch(sid: string, data: session.SessionData, callback?: Callback): void {
+    // The idle expiry of a session its request did not change.
+    this.track(this.repository.update({ sid }, { expires: expiresOf(data) })).then(() => callback?.(), error => callback?.(error));
+  }
+
+  destroy(sid: string, callback?: Callback): void {
+    this.track(this.repository.delete({ sid })).then(() => callback?.(), error => callback?.(error));
+  }
+
+  all(callback: Callback<Record<string, session.SessionData>>): void {
+    this.track(this.repository.find()).then(
+      sessions => callback(null, Object.fromEntries(alive(sessions).map(({ sid, data }) => [sid, data]))),
+      callback,
+    );
+  }
+
+  /** The sessions of a user, not expired. */
+  async sessionsOf(login: string): Promise<StoredSession[]> {
+    return alive(await this.repository.find({ where: { login } }));
+  }
+
+  /** Removes the expired sessions. */
+  async prune(): Promise<void> {
+<%_ if (databaseTypeSql) { _%>
+    await this.repository.delete({ expires: LessThan(new Date()) });
+<%_ } else { _%>
+    await this.repository.delete({ expires: { $lt: new Date() } } as any);
+<%_ } _%>
+  }
+
+  /** An operation on the database, in progress until it settles. */
+  private track<T>(operation: Promise<T>): Promise<T> {
+    this.pending.add(operation);
+    const settled = (): void => {
+      this.pending.delete(operation);
+    };
+    operation.then(settled, settled);
+    return operation;
+  }
+
+  private async save(sid: string, data: session.SessionData): Promise<void> {
+    const found = await this.repository.findOne({ where: { sid } });
+    await this.repository.save({ ...found, sid, login: (data as any).user?.login ?? null, expires: expiresOf(data), data: JSON.stringify(data) });
+  }
+}
+
+/** The end of a session: the expiry of its cookie with remember-me, else 30 minutes after its last request. */
+function expiresOf(data: session.SessionData): Date {
+  return data.cookie?.expires ? new Date(data.cookie.expires) : new Date(Date.now() + SESSION_MAX_AGE);
+}
+
+/** The sessions not expired, with their data. */
+function alive(sessions: Session[]): StoredSession[] {
+  const now = Date.now();
+  return sessions.filter(stored => stored.expires.getTime() > now).map(({ sid, data }) => ({ sid, data: JSON.parse(data) }));
+}

package/generators/node-server/templates/server/src/auth/user.jwt.controller.ts.ejs

@@ -0,0 +1,26 @@
+import { Body, Controller, Logger, Post, Res, Req, HttpCode } from '@nestjs/common';
+import { Response, Request } from 'express';
+import { UserLoginDTO } from './dto/user-login.dto.ts';
+import { AuthService } from './auth.service.ts';
+import { ApiTags, ApiResponse, ApiOperation } from '@nestjs/swagger';
+
+@Controller('api')
+@ApiTags('user-jwt-controller')
+export class UserJWTController {
+  logger = new Logger('UserJWTController');
+
+  constructor(private readonly authService: AuthService) {}
+
+  @Post('/authenticate')
+  @HttpCode(200)
+  @ApiOperation({ summary: 'Authorization api retrieving token' })
+  @ApiResponse({
+    status: 200,
+    description: 'Authorized',
+  })
+  async authorize(@Req() req: Request, @Body() user: UserLoginDTO, @Res() res: Response): Promise<any> {
+    const jwt = await this.authService.login(user);
+    res.setHeader('Authorization', 'Bearer ' + jwt.id_token);
+    return res.json(jwt);
+  }
+}

package/generators/node-server/templates/server/src/auth/user.oauth2.controller.ts.ejs

@@ -0,0 +1,78 @@
+import { randomUUID } from 'node:crypto';
+
+import { Controller, Get, Logger, Post, Res, UseGuards, Req } from '@nestjs/common';
+import { AuthService } from './auth.service.ts';
+import { ApiTags, ApiResponse, ApiOperation, ApiExcludeEndpoint } from '@nestjs/swagger';
+import { setCsrfCookie } from './csrf.middleware.ts';
+import { OAuth2LoginGuard } from './guards/oauth2-login.guard.ts';
+import { OAuth2Config } from './oauth2.config.ts';
+
+@Controller()
+@ApiTags('user-oauth2-controller')
+export class UserOauth2Controller {
+  logger = new Logger('UserOauth2Controller');
+
+  constructor(
+    private readonly authService: AuthService,
+    private readonly oauth2Config: OAuth2Config,
+  ) {}
+
+  @ApiExcludeEndpoint()
+  @UseGuards(OAuth2LoginGuard)
+  @Get('/login/oauth2/code/oidc')
+  @ApiOperation({ summary: 'Backend redirect' })
+  @ApiResponse({
+    status: 200,
+    description: 'Redirect oauth2 oidc after login',
+  })
+  redirect(@Req() req: any, @Res() res: any): void {
+    const { user } = req;
+    // Like Spring Security, a new session for the authenticated user (the id of the session before the login is not
+    // kept), with the CSRF token the clients send back as X-XSRF-TOKEN.
+    req.session.regenerate((error?: Error) => {
+      if (error) {
+        this.logger.error(`The session of the login could not be created: ${error.message}`);
+        res.status(500).end();
+        return;
+      }
+      req.session.user = user;
+      req.session.csrfToken = randomUUID();
+      setCsrfCookie(res, req.session.csrfToken);
+      req.session.save(() => res.redirect('/'));
+    });
+  }
+
+  @ApiExcludeEndpoint()
+  @Get('/oauth2/authorization/oidc')
+  @UseGuards(OAuth2LoginGuard)
+  @ApiOperation({ summary: 'Perform login oauth2 oidc from client' })
+  @ApiResponse({
+    status: 200,
+    description: 'Redirect to login oauth2 oidc',
+  })
+  loginAuthOidc(): void {
+    return;
+  }
+
+  @ApiExcludeEndpoint()
+  @Post('/api/logout')
+  @ApiOperation({ summary: 'Perform logout oauth2 oidc from client' })
+  @ApiResponse({
+    status: 201,
+    description: 'Logout oauth2 oidc',
+  })
+  logoutAuthOidc(@Req() req: any): any {
+    if (req.session && req.session.user) {
+      const idToken = req.session.user.idToken;
+      req.session.destroy();
+      // Like JHipster Spring Boot, the logout URL of the provider logs out the session of the user there, and redirects
+      // back to the application (the client goes to it).
+      const logoutUrl = new URL(this.oauth2Config.logoutUrl);
+      logoutUrl.searchParams.set('id_token_hint', idToken);
+      logoutUrl.searchParams.set('post_logout_redirect_uri', req.headers.origin ?? `${req.protocol}://${req.get('host')}`);
+      return { idToken, logoutUrl: logoutUrl.toString() };
+    }
+    return;
+  }
+
+}

package/generators/node-server/templates/server/src/auth/user.session.controller.ts.ejs

@@ -0,0 +1,103 @@
+import { randomBytes, randomUUID } from 'node:crypto';
+
+import { Body, Controller, Delete, Get, HttpCode, Logger, Param, Post, Req, Res, UnauthorizedException, UseGuards } from '@nestjs/common';
+import { ApiConsumes, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { Request, Response } from 'express';
+import { AuthService } from './auth.service.ts';
+import { checkLoginCsrfToken, REMEMBER_ME_MAX_AGE, setCsrfCookie } from './csrf.middleware.ts';
+import { sessionUser } from './session-user.middleware.ts';
+import { AuthGuard } from './guards/auth.guard.ts';
+import { SessionStore } from './session.store.ts';
+
+/** The form of the session login, the one the JHipster clients post, like the formLogin of JHipster Spring Boot. */
+interface LoginForm {
+  username?: string;
+  password?: string;
+  'remember-me'?: string;
+}
+
+/** The values of the remember-me parameter that ask for it, like the ones of the RememberMeServices of Spring Security. */
+const REMEMBER_ME_VALUES = ['true', 'on', 'yes', '1'];
+
+/** A session of the user, as the sessions page of the clients shows it, like the PersistentToken of JHipster Spring Boot. */
+interface SessionDTO {
+  series: string;
+  tokenDate: string;
+  ipAddress?: string;
+  userAgent?: string;
+}
+
+@Controller('api')
+@ApiTags('user-session-controller')
+export class UserSessionController {
+  logger = new Logger('UserSessionController');
+
+  constructor(
+    private readonly authService: AuthService,
+    private readonly sessionStore: SessionStore,
+  ) {}
+
+  @Post('/authentication')
+  @HttpCode(200)
+  @ApiConsumes('application/x-www-form-urlencoded')
+  @ApiOperation({ summary: 'Log in, in a new session' })
+  @ApiResponse({ status: 200, description: 'Logged in' })
+  @ApiResponse({ status: 401, description: 'Invalid login, password, or a user not activated' })
+  @ApiResponse({ status: 403, description: 'Without the CSRF token of the XSRF-TOKEN cookie' })
+  async authenticate(@Req() req: Request, @Res({ passthrough: true }) res: Response, @Body() form: LoginForm): Promise<void> {
+    checkLoginCsrfToken(req);
+    if (typeof form?.username !== 'string' || typeof form.password !== 'string' || !form.username || !form.password) {
+      throw new UnauthorizedException();
+    }
+    const user = sessionUser(await this.authService.authenticate(form.username, form.password));
+    // Like Spring Security, a new session for the authenticated user (the id of the session before the login is not
+    // kept), with the CSRF token the clients send back as X-XSRF-TOKEN.
+    await new Promise<void>((resolve, reject) => req.session.regenerate((error?: Error) => (error ? reject(error) : resolve())));
+    const session = req.session as any;
+    session.user = user;
+    session.csrfToken = randomUUID();
+    // The session as the sessions page shows it, like the PersistentToken of JHipster Spring Boot: its series (random,
+    // not its id), the date, the address and the browser of its login.
+    session.series = randomBytes(16).toString('base64url');
+    session.tokenDate = new Date().toISOString().slice(0, 10);
+    session.ipAddress = req.ip;
+    session.userAgent = req.get('user-agent');
+    if (REMEMBER_ME_VALUES.includes(String(form['remember-me']).toLowerCase())) {
+      // Like the remember-me of JHipster Spring Boot, the login is kept after the browser is closed, until the session
+      // is unused for 31 days (its cookie expires 31 days after the login).
+      session.cookie.maxAge = REMEMBER_ME_MAX_AGE;
+    }
+    setCsrfCookie(res, session.csrfToken);
+    await new Promise<void>((resolve, reject) => session.save((error?: Error) => (error ? reject(error) : resolve())));
+  }
+
+  @Post('/logout')
+  @HttpCode(200)
+  @ApiOperation({ summary: 'Log out, ending the session' })
+  @ApiResponse({ status: 200, description: 'Logged out' })
+  async logout(@Req() req: Request): Promise<void> {
+    await new Promise<void>(resolve => req.session.destroy(() => resolve()));
+  }
+
+  @Get('/account/sessions')
+  @UseGuards(AuthGuard)
+  @ApiOperation({ summary: 'The sessions of the current user, like the persistent tokens of JHipster Spring Boot' })
+  @ApiResponse({ status: 200, description: 'The sessions of the user' })
+  async getCurrentSessions(@Req() req: Request): Promise<SessionDTO[]> {
+    const { login } = (req.session as any).user;
+    return (await this.sessionStore.sessionsOf(login))
+      .filter(({ data }) => data.series)
+      .map(({ data: { series, tokenDate, ipAddress, userAgent } }) => ({ series, tokenDate, ipAddress, userAgent }));
+  }
+
+  @Delete('/account/sessions/:series')
+  @UseGuards(AuthGuard)
+  @ApiOperation({ summary: 'Ends a session of the current user, like the invalidation of a persistent token of JHipster Spring Boot' })
+  @ApiResponse({ status: 200, description: 'The session of the series, if any, ended' })
+  async invalidateSession(@Req() req: Request, @Param('series') series: string): Promise<void> {
+    const { login } = (req.session as any).user;
+    for (const { sid } of (await this.sessionStore.sessionsOf(login)).filter(({ data }) => data.series === series)) {
+      await new Promise<void>((resolve, reject) => this.sessionStore.destroy(sid, error => (error ? reject(error as Error) : resolve())));
+    }
+  }
+}

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

@@ -0,0 +1,19 @@
+import { Global, Module } from '@nestjs/common';
+
+import { HeaderUtil } from './header-util.ts';
+<%_ if (authenticationTypeOauth2) { _%>
+import { OAuth2Config } from '../auth/oauth2.config.ts';
+<%_ } _%>
+<%_ if (generateUserManagement) { _%>
+import { PasswordService } from '../auth/password.service.ts';
+<%_ } _%>
+
+const providers = [HeaderUtil<% if (authenticationTypeOauth2) { %>, OAuth2Config<% } %><% if (generateUserManagement) { %>, PasswordService<% } %>];
+
+/**
+ * The providers every module of the application uses, reading the configuration with ConfigService, like the beans of
+ * JHipster Spring Boot: the headers of the responses<% if (authenticationTypeOauth2) { %>, the endpoints of the OpenID Connect provider<% } %><% if (generateUserManagement) { %>, the passwords of the users<% } %>.
+ */
+@Global()
+@Module({ providers, exports: providers })
+export class CommonModule {}

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

@@ -0,0 +1,13 @@
+import { Column, CreateDateColumn, UpdateDateColumn } from 'typeorm';
+
+export abstract class BaseEntity {
+   // The creation audit columns are readable but never updated, like the updatable = false columns of JHipster Spring Boot.
+   @Column({ nullable: true, update: false })
+   createdBy?: string;
+   @CreateDateColumn({ nullable: true, update: false })
+   createdDate?: Date;
+   @Column({ nullable: true })
+   lastModifiedBy?: string;
+   @UpdateDateColumn({ nullable: true })
+   lastModifiedDate?: Date;
+}

package/generators/node-server/templates/server/src/common/database/column-transformers.spec.ts.ejs

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  blobTransformer,
+  durationTransformer,
+  formatDuration,
+  numberTransformer,
+  parseDuration,
+} from './column-transformers.ts';
+
+describe('column transformers', () => {
+  it('should read a bigint or a decimal given as a string as a number', () => {
+    expect(numberTransformer.from('25179')).toBe(25179);
+    expect(numberTransformer.from('25829.80')).toBe(25829.8);
+    expect(numberTransformer.from(null)).toBeNull();
+  });
+
+  it('should read a blob given as a Buffer as the string it stored', () => {
+    expect(blobTransformer.from(Buffer.from('aGlwc3Rlcg=='))).toBe('aGlwc3Rlcg==');
+    expect(blobTransformer.from('aGlwc3Rlcg==')).toBe('aGlwc3Rlcg==');
+  });
+
+  it('should store a duration as its nanoseconds and read it back as an ISO-8601 duration', () => {
+    expect(durationTransformer.to('PT1H30M')).toBe('5400000000000');
+    expect(durationTransformer.from('5400000000000')).toBe('PT1H30M');
+    expect(durationTransformer.to(null)).toBeNull();
+  });
+
+  it.each([
+    ['PT0S', 'PT0S'],
+    ['PT90M', 'PT1H30M'],
+    ['PT0.5S', 'PT0.5S'],
+    ['PT-0.5S', 'PT-0.5S'],
+    ['PT-1.5S', 'PT-1.5S'],
+    ['P2DT3H', 'PT51H'],
+    ['PT-90M', 'PT-1H-30M'],
+    ['-PT1H', 'PT-1H'],
+    ['PT1.000000001S', 'PT1.000000001S'],
+  ])('should format the duration %s as %s, like Duration of Java', (text, formatted) => {
+    expect(formatDuration(parseDuration(text))).toBe(formatted);
+  });
+
+  it.each(['PT', 'P', 'P1DT', '1H', 'PTXS'])('should refuse %s, not an ISO-8601 duration', text => {
+    expect(() => parseDuration(text)).toThrow('is not an ISO-8601 duration');
+  });
+});

package/generators/node-server/templates/server/src/common/database/column-transformers.ts.ejs

@@ -0,0 +1,69 @@
+import type { ValueTransformer } from 'typeorm';
+
+/**
+ * The transformers of the columns whose values the database drivers do not give as the API exchanges them, the values
+ * of the JSON of JHipster Spring Boot.
+ */
+
+/** A bigint or a decimal, which the PostgreSQL and MySQL drivers give as a string: a number, like the clients read it. */
+export const numberTransformer: ValueTransformer = {
+  to: (value: number | null | undefined) => value,
+  from: (value: string | number | null) => (value === null || value === undefined ? value : Number(value)),
+};
+
+/** A blob, which the drivers give as a Buffer: the base64 or text string the API received. */
+export const blobTransformer: ValueTransformer = {
+  to: (value: string | null | undefined) => value,
+  from: (value: Buffer | string | null) => (Buffer.isBuffer(value) ? value.toString() : value),
+};
+
+const NANOS_PER_SECOND = 1_000_000_000n;
+const ISO_DURATION =
+  /^([-+]?)P(?:([-+]?\d+)D)?(?:T(?:([-+]?\d+)H)?(?:([-+]?\d+)M)?(?:([-+]?)(\d+)(?:[.,](\d{0,9}))?S)?)?$/i;
+
+/** The nanoseconds of an ISO-8601 duration, like Duration.parse of Java: PT1H30M, P2DT3H, PT-0.5S. */
+export function parseDuration(text: string): bigint {
+  const match = ISO_DURATION.exec(text);
+  if (!match || /T$/i.test(text) || text.toUpperCase() === 'P') {
+    throw new Error(`${text} is not an ISO-8601 duration, like PT1H30M`);
+  }
+  const [, sign, days = '0', hours = '0', minutes = '0', secondsSign = '', seconds = '0', fraction = ''] = match;
+  const secondsNanos = BigInt(seconds) * NANOS_PER_SECOND + BigInt(fraction.padEnd(9, '0'));
+  const total =
+    ((BigInt(days) * 24n + BigInt(hours)) * 60n + BigInt(minutes)) * 60n * NANOS_PER_SECOND +
+    (secondsSign === '-' ? -secondsNanos : secondsNanos);
+  return sign === '-' ? -total : total;
+}
+
+/** The ISO-8601 duration of nanoseconds, like Duration.toString of Java: PT1H30M, PT0.5S, PT-1H. */
+export function formatDuration(nanos: bigint): string {
+  if (nanos === 0n) return 'PT0S';
+  // Like Java, the seconds rounded down and the positive nanoseconds of the second.
+  let seconds = nanos / NANOS_PER_SECOND;
+  let nanosOfSecond = nanos % NANOS_PER_SECOND;
+  if (nanosOfSecond < 0n) {
+    seconds -= 1n;
+    nanosOfSecond += NANOS_PER_SECOND;
+  }
+  const effectiveSeconds = seconds < 0n && nanosOfSecond > 0n ? seconds + 1n : seconds;
+  const hours = effectiveSeconds / 3600n;
+  const minutes = (effectiveSeconds % 3600n) / 60n;
+  const secs = effectiveSeconds % 60n;
+  let text = 'PT';
+  if (hours !== 0n) text += `${hours}H`;
+  if (minutes !== 0n) text += `${minutes}M`;
+  if (secs === 0n && nanosOfSecond === 0n && text.length > 2) return text;
+  text += seconds < 0n && nanosOfSecond > 0n && secs === 0n ? '-0' : `${secs}`;
+  if (nanosOfSecond > 0n) {
+    const digits = `${seconds < 0n ? 2n * NANOS_PER_SECOND - nanosOfSecond : nanosOfSecond + NANOS_PER_SECOND}`;
+    text += `.${digits.slice(1).replace(/0+$/, '')}`;
+  }
+  return `${text}S`;
+}
+
+/** A duration, an ISO-8601 text in the API and its nanoseconds in a bigint column, like JHipster Spring Boot. */
+export const durationTransformer: ValueTransformer = {
+  to: (value: string | null | undefined) => (value === null || value === undefined ? value : parseDuration(value).toString()),
+  from: (value: string | number | bigint | null) =>
+    value === null || value === undefined ? value : formatDuration(BigInt(value)),
+};

package/generators/node-server/templates/server/src/common/database/column-types.spec.ts.ejs

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest';
+import { databaseColumnType, databaseDatetimePrecision } from './column-types.ts';
+
+describe('column types', () => {
+  it('should give the long blobs and texts of MySQL and MariaDB, like JHipster Spring Boot', () => {
+    expect(databaseColumnType('mysql', 'blob')).toBe('longblob');
+    expect(databaseColumnType('mariadb', 'text')).toBe('longtext');
+  });
+
+  it('should keep the types better-sqlite3 has and the other types', () => {
+    expect(databaseColumnType('better-sqlite3', 'blob')).toBe('blob');
+    expect(databaseColumnType('better-sqlite3', 'text')).toBe('text');
+    expect(databaseColumnType('mysql', 'varchar')).toBe('varchar');
+    expect(databaseColumnType('mysql', Date)).toBe(Date);
+  });
+
+  it('should give the microseconds of the instants of MySQL and MariaDB only', () => {
+    expect(databaseDatetimePrecision('mysql')).toBe(6);
+    expect(databaseDatetimePrecision('better-sqlite3')).toBeUndefined();
+  });
+});

package/generators/node-server/templates/server/src/common/database/column-types.ts.ejs

@@ -0,0 +1,29 @@
+import type { ColumnType } from 'typeorm';
+
+import { config } from '../../config.ts';
+
+/**
+ * The databases with the column types of JHipster Spring Boot better-sqlite3 (dev and test) has not: the blobs and the
+ * texts up to 4 GB (longblob, longtext; blob and text keep 64 KB) and the microseconds of the instants (datetime(6)) of
+ * MySQL and MariaDB, like the blobType, clobType and datetimeType properties of its Liquibase changelogs.
+ */
+const LONG_TYPES_DATABASES = ['mysql', 'mariadb', 'aurora-mysql'];
+
+const LONG_TYPES: Partial<Record<string, ColumnType>> = { blob: 'longblob', text: 'longtext' };
+
+/** The type of a column on a database: a long blob or text on MySQL and MariaDB, the type itself on the others. */
+export const databaseColumnType = (databaseType: string, type: ColumnType): ColumnType =>
+  (LONG_TYPES_DATABASES.includes(databaseType) && typeof type === 'string' && LONG_TYPES[type]) || type;
+
+/** The precision of an instant column on a database: the microseconds on MySQL and MariaDB, the default on the others. */
+export const databaseDatetimePrecision = (databaseType: string): number | undefined =>
+  LONG_TYPES_DATABASES.includes(databaseType) ? 6 : undefined;
+
+/**
+ * The type of a column on the database of the active profiles, for the @Column decorators: the migrations give the same
+ * one with the driver of their connection (migrations/support/schema.ts), so the tables are the ones the entities map.
+ */
+export const columnType = (type: ColumnType): ColumnType => databaseColumnType(config.get('database.type'), type);
+
+/** The precision of an instant column on the database of the active profiles, for the @Column decorators. */
+export const datetimePrecision = (): number | undefined => databaseDatetimePrecision(config.get('database.type'));

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

@@ -0,0 +1,66 @@
+import "reflect-metadata";
+import { describe, expect, it } from 'vitest';
+import { PageRequest } from './pagination.entity.ts';
+
+describe('PageRequest', () => {
+  it('passing default number parameters', () => {
+    const pageRequest = new PageRequest(
+      0,
+      20,
+      'id,ASC',
+    );
+    expect(pageRequest.page).toBe(0);
+    expect(pageRequest.size).toBe(20);
+    expect(pageRequest.asOrder()).toMatchObject({ id: 'ASC' });
+  });
+
+  it('passing default strings parameters', () => {
+    const pageRequest = new PageRequest(
+      '0',
+      '20',
+      'id,ASC',
+    );
+    expect(pageRequest.page).toBe(0);
+    expect(pageRequest.size).toBe(20);
+    expect(pageRequest.asOrder()).toMatchObject({ id: 'ASC' });
+  });
+
+  it('passing non default strings parameters', () => {
+    const pageRequest = new PageRequest(
+      '10',
+      '30',
+      'foo,DESC',
+    );
+    expect(pageRequest.page).toBe(10);
+    expect(pageRequest.size).toBe(30);
+    expect(pageRequest.asOrder()).toMatchObject({ foo: 'DESC' });
+  });
+
+  it('caps the size like Spring Data, and ignores a negative page or a size below 1', () => {
+    expect(new PageRequest(0, 100000).size).toBe(2000);
+    const pageRequest = new PageRequest(-1, 0);
+    expect(pageRequest.page).toBe(0);
+    expect(pageRequest.size).toBe(20);
+  });
+
+  it('sorts on several properties, the direction case insensitive and ascending by default', () => {
+    const pageRequest = new PageRequest(0, 20, ['name,desc', 'id']);
+    expect(pageRequest.asOrder()).toEqual({ name: 'DESC', id: 'ASC' });
+  });
+
+  it('sorts on the properties of a relationship', () => {
+    const pageRequest = new PageRequest(0, 20, ['region.name,asc', 'region.id,desc']);
+    expect(pageRequest.asOrder()).toEqual({ region: { name: 'ASC', id: 'DESC' } });
+  });
+
+  it('rejects a property out of the sort properties', () => {
+    expect(() => new PageRequest(0, 20, 'password,asc', ['id', 'name'])).toThrow('Invalid sort property: password');
+    expect(new PageRequest(0, 20, 'name,asc', ['id', 'name']).asOrder()).toEqual({ name: 'ASC' });
+  });
+
+  it('rejects a property the sort check refuses', () => {
+    const isSortable = (property: string): boolean => property !== 'password';
+    expect(() => new PageRequest(0, 20, 'password,asc', isSortable)).toThrow('Invalid sort property: password');
+    expect(new PageRequest(0, 20, 'name,asc', isSortable).asOrder()).toEqual({ name: 'ASC' });
+  });
+});