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

package/generators/node-server/generators/bootstrap/command.js

@@ -0,0 +1,5 @@
+import { asCommand } from 'generator-jhipster';
+
+export default asCommand({
+  configs: {},
+});

package/generators/node-server/generators/bootstrap/generator.js

@@ -0,0 +1,84 @@
+import BaseApplicationGenerator from 'generator-jhipster/generators/base-application';
+import { hibernateSnakeCase } from 'generator-jhipster/generators/server/support';
+import { prepareSqlApplicationProperties } from 'generator-jhipster/generators/spring-boot/generators/data-relational/support';
+
+import { SERVER_NODEJS_SRC_DIR } from '../../../generator-nodejs-constants.js';
+
+export default class extends BaseApplicationGenerator {
+  constructor(args, opts, features) {
+    super(args, opts, { ...features, sbsBlueprint: true });
+  }
+
+  async beforeQueue() {
+    // Node server is a Typescript server, we need typescript preparation.
+    await this.dependsOnBootstrap('client');
+    await this.dependsOnBootstrap('server');
+  }
+
+  get [BaseApplicationGenerator.LOADING]() {
+    return this.asLoadingTaskGroup({
+      async loadingTemplateTask({ applicationDefaults }) {
+        applicationDefaults({
+          temporaryDir: 'tmp/',
+          dockerServicesDir: 'docker/',
+          nodeServerRootDir: `${SERVER_NODEJS_SRC_DIR}/`,
+          jhiTablePrefix: ({ jhiPrefix }) => hibernateSnakeCase(jhiPrefix),
+          clientPackageManager: 'npm',
+          dbPortValue: undefined,
+          // As in JHipster's Spring Boot application, syncUserWithIdp is disabled by default, enabled for a gateway or
+          // when an entity has a relationship with User (JHipster only derives it for a Java backend). Delayed until
+          // anyEntityHasRelationshipWithUser is defined, before JHipster derives the built-in entities from it.
+          syncUserWithIdp: ({ authenticationType, applicationType, anyEntityHasRelationshipWithUser }) =>
+            authenticationType === 'oauth2' && (applicationType === 'gateway' || anyEntityHasRelationshipWithUser),
+          // The scripts of the client run from the root package.json with --prefix, not -w (the e2e default): an application
+          // of a JHipster workspace is itself a workspace, and npm resolves -w from the root of the outer one.
+          clientNpmRun: ({ clientRootDir }) => (clientRootDir ? `npm --prefix ${clientRootDir} run` : 'npm run'),
+          clientNgCommand: ({ clientRootDir }) => (clientRootDir ? `npm --prefix ${clientRootDir} exec -- ng` : 'ng'),
+        });
+      },
+    });
+  }
+
+  get [BaseApplicationGenerator.PREPARING]() {
+    return this.asPreparingTaskGroup({
+      prettierFolders({ application }) {
+        // The prettier:check and prettier:format scripts of the root package.json cover the server and the client
+        // workspaces (JHipster only adds the client sources, and the build plugins of Angular at the root).
+        const { nodeServerRootDir, clientRootDir } = application;
+        const folders = [nodeServerRootDir, ...['src', 'test', 'e2e', 'scripts'].map(dir => `${nodeServerRootDir}${dir}/**/`)];
+        if (application.clientFrameworkAny) {
+          folders.push(clientRootDir);
+          if (application.clientFrameworkAngular) {
+            folders.push(`${clientRootDir}build-plugins/**/`);
+          }
+        }
+        application.prettierFolders.push(...folders.filter(folder => !application.prettierFolders.includes(folder)));
+      },
+      preparing({ application, applicationDefaults }) {
+        if (application.databaseTypeSql) {
+          prepareSqlApplicationProperties({ application });
+        } else {
+          applicationDefaults({
+            prodDatabaseName: undefined,
+            prodDatabaseUsername: undefined,
+            prodDatabasePassword: undefined,
+            devDatabaseName: undefined,
+            devDatabaseUsername: undefined,
+            devDatabasePassword: undefined,
+          });
+        }
+      },
+    });
+  }
+
+  get [BaseApplicationGenerator.DEFAULT]() {
+    return this.asDefaultTaskGroup({
+      postPreparing({ application }) {
+        if (application.authority) {
+          // The clients of JHipster with the screens of the built-in Authority, which their user management uses.
+          application.authority.skipClient = !application.clientFrameworkAngular && !application.clientFrameworkVue;
+        }
+      },
+    });
+  }
+}

package/generators/node-server/generators/bootstrap/index.js

@@ -0,0 +1,2 @@
+export { default } from './generator.js';
+export { default as command } from './command.js';

package/generators/node-server/generators/migrations/command.js

@@ -0,0 +1,5 @@
+import { asCommand } from 'generator-jhipster';
+
+export default asCommand({
+  configs: {},
+});

package/generators/node-server/generators/migrations/files.js

@@ -0,0 +1,42 @@
+import { SERVER_NODEJS_SRC_DIR } from '../../../generator-nodejs-constants.js';
+
+const SERVER_NODEJS_DIR = `${SERVER_NODEJS_SRC_DIR}/`;
+
+/**
+ * The migrations of a changelog of this generation, like the Liquibase changelogs of its entity: for its creation its table,
+ * then its constraints when it has some; for an update its fields, then its relationships; for its removal its tables.
+ */
+export const migrationFiles = {
+  migrations: [
+    {
+      path: SERVER_NODEJS_DIR,
+      condition: ctx => ctx.nodejsMigration,
+      renameTo: data => `${SERVER_NODEJS_DIR}src/migrations/${data.nodejsMigration.fileName}.ts`,
+      templates: ['src/migrations/_entityMigration_.ts'],
+    },
+    {
+      path: SERVER_NODEJS_DIR,
+      condition: ctx => ctx.nodejsConstraintsMigration,
+      renameTo: data => `${SERVER_NODEJS_DIR}src/migrations/${data.nodejsConstraintsMigration.fileName}.ts`,
+      templates: ['src/migrations/_entityConstraintsMigration_.ts'],
+    },
+    {
+      path: SERVER_NODEJS_DIR,
+      condition: ctx => ctx.nodejsUpdatedMigration,
+      renameTo: data => `${SERVER_NODEJS_DIR}src/migrations/${data.nodejsUpdatedMigration.fileName}.ts`,
+      templates: ['src/migrations/_entityUpdatedMigration_.ts'],
+    },
+    {
+      path: SERVER_NODEJS_DIR,
+      condition: ctx => ctx.nodejsUpdatedConstraintsMigration,
+      renameTo: data => `${SERVER_NODEJS_DIR}src/migrations/${data.nodejsUpdatedConstraintsMigration.fileName}.ts`,
+      templates: ['src/migrations/_entityUpdatedConstraintsMigration_.ts'],
+    },
+    {
+      path: SERVER_NODEJS_DIR,
+      condition: ctx => ctx.nodejsRemovedMigration,
+      renameTo: data => `${SERVER_NODEJS_DIR}src/migrations/${data.nodejsRemovedMigration.fileName}.ts`,
+      templates: ['src/migrations/_entityRemovedMigration_.ts'],
+    },
+  ],
+};

package/generators/node-server/generators/migrations/generator.js

@@ -0,0 +1,108 @@
+import BaseApplicationGenerator from 'generator-jhipster/generators/base-application';
+import {
+  CHANGELOGS_CUSTOM_OBJECT,
+  changelogsCustomObject,
+  getEntityChangelogs,
+  isNewEntityChangelog,
+} from 'generator-jhipster/generators/base-application/generators/database-changelogs/support';
+import { CONTEXT_DATA_APPLICATION_ENTITIES_KEY } from 'generator-jhipster/generators/base-application/support';
+
+import { changelogMigrations, migrationOfFile } from '../../support/index.js';
+
+import { migrationFiles } from './files.js';
+
+/**
+ * The migrations of the entities of a SQL server, like the incremental Liquibase changelogs of JHipster Spring Boot: the
+ * migrations of the changelogs of the entities JHipster records (jhipster:base-application:database-changelogs, the
+ * changelogs custom object), a creation AddedEntity and AddedEntityConstraints, an update UpdatedEntity and
+ * UpdatedEntityConstraints (see support/migrations.js). A generation writes the migrations of its own changelogs, recorded
+ * in them, and registers every one: the ones of the former changelogs as they record them, written once.
+ */
+export default class extends BaseApplicationGenerator {
+  /** The migrations of the changelogs of this generation, with their entity. */
+  #migrations = [];
+
+  constructor(args, options, features) {
+    // The changelogs once the entities are prepared: their migrations are written from the entities and their fields.
+    super(args, options, { ...features, customObjects: [changelogsCustomObject] });
+  }
+
+  async beforeQueue() {
+    await this.dependsOnJHipster('jhipster-nodejs:node-server:bootstrap');
+  }
+
+  /** The changelogs of the entities, the ones of this generation recorded (see getEntityChangelogs of JHipster). */
+  get changelogs() {
+    return getEntityChangelogs(this);
+  }
+
+  /** The entities of the application with a table of the server, as JHipster prepares them. */
+  get #entities() {
+    return [...this.getContextData(CONTEXT_DATA_APPLICATION_ENTITIES_KEY, { factory: () => new Map() }).values()];
+  }
+
+  get [BaseApplicationGenerator.COMPOSING]() {
+    return this.asComposingTaskGroup({
+      async composeChangelogs() {
+        await this.composeWithJHipster('jhipster:base-application:database-changelogs');
+      },
+    });
+  }
+
+  get [BaseApplicationGenerator.objectPriority(CHANGELOGS_CUSTOM_OBJECT, 'postPreparing')]() {
+    return {
+      prepareMigrations: ({ changelogs }) => {
+        const entities = this.#entities;
+        for (const changelog of changelogs.filter(changelog => isNewEntityChangelog(this, changelog))) {
+          // The entity of a creation or an update; a removal has none, its migration written from the entity before it.
+          const entity = entities.find(entity => entity.name === changelog.entityName);
+          if (!(entity ?? changelog.previousEntity).skipServer) {
+            this.#prepareMigrations(changelog, entity, entities);
+          }
+        }
+      },
+    };
+  }
+
+  get [BaseApplicationGenerator.WRITING_OBJECTS]() {
+    return this.asWritingObjectsTaskGroup({
+      async writeMigrations({ application }) {
+        for (const { entity, migrations } of this.#migrations) {
+          await this.writeFiles({ sections: migrationFiles, context: { ...application, ...entity, ...migrations } });
+        }
+      },
+    });
+  }
+
+  get [BaseApplicationGenerator.POST_WRITING_OBJECTS]() {
+    return this.asPostWritingObjectsTaskGroup({
+      registerMigrations({ source }) {
+        // The migrations every changelog records, the ones of this generation included.
+        for (const changelog of this.changelogs) {
+          for (const fileName of this.getObjectConfig(changelogName(changelog))?.nodejsMigrations ?? []) {
+            source.addMigrationToNodeConfig(migrationOfFile(fileName));
+          }
+        }
+      },
+    });
+  }
+
+  /**
+   * The migrations of a changelog of this generation (support/migrations.js), written with its entity, and recorded in its
+   * object (nodejsMigrations), which the next generations register.
+   */
+  #prepareMigrations(changelog, entity, entities) {
+    const migrations = changelogMigrations(changelog, entity, entities);
+    this.#migrations.push({ entity, migrations });
+    const name = changelogName(changelog);
+    this.setObjectConfig(name, {
+      ...this.getObjectConfig(name),
+      nodejsMigrations: Object.values(migrations)
+        .filter(Boolean)
+        .map(migration => migration.fileName),
+    });
+  }
+}
+
+/** The name of the object of a changelog, like JHipster names it. */
+const changelogName = ({ changelogDate, entityName }) => `${changelogDate}_${entityName}`;

package/generators/node-server/generators/migrations/index.js

@@ -0,0 +1,2 @@
+export { default } from './generator.js';
+export { default as command } from './command.js';

package/generators/node-server/generators/migrations/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/generators/migrations/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/generators/migrations/templates/server/src/migrations/_entityRemovedMigration_.ts.ejs

@@ -0,0 +1,15 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+/** Removed the entity <%= nodejsRemovedMigration.entityName %>: its join tables and its table dropped. */
+export class <%= nodejsRemovedMigration.className %> implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+<%_ for (const name of nodejsRemovedMigration.joinTables) { _%>
+    await queryRunner.dropTable('<%= name %>', true);
+<%_ } _%>
+    await queryRunner.dropTable('<%= nodejsRemovedMigration.tableName %>', true);
+  }
+
+  public async down(_queryRunner: QueryRunner): Promise<void> {
+    // The table of the removed entity and its join tables are not restored, nor their values.
+  }
+}

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

@@ -0,0 +1,60 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+<%_ if (nodejsUpdatedConstraintsMigration.schemaImports) { _%>
+
+import { <%= nodejsUpdatedConstraintsMigration.schemaImports %> } from './support/schema.ts';
+<%_ } _%>
+
+/**
+ * Updated the relationships of the entity <%= entityClass %>: the join columns, their foreign keys and the join tables of its
+ * removed relationships dropped, the ones of its added relationships.
+ */
+export class <%= nodejsUpdatedConstraintsMigration.className %> implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+<%_ for (const name of nodejsUpdatedConstraintsMigration.removedJoinTables) { _%>
+    await queryRunner.dropTable('<%= name %>', true);
+<%_ } _%>
+<%_ if (nodejsUpdatedConstraintsMigration.removedJoinColumnNames) { _%>
+    await dropColumns(queryRunner, '<%= nodejsUpdatedConstraintsMigration.tableName %>', <%- nodejsUpdatedConstraintsMigration.removedJoinColumnNames %>);
+<%_ } _%>
+<%_ if (nodejsUpdatedConstraintsMigration.addedJoinColumnNames) { _%>
+    await addColumns(
+      queryRunner,
+      '<%= nodejsUpdatedConstraintsMigration.tableName %>',
+      [
+<%_ for (const column of nodejsUpdatedConstraintsMigration.addedJoinColumns) { _%>
+        { name: '<%= column.name %>', type: <%- column.type %>, nullable: true },
+<%_ } _%>
+      ],
+<%_ if (nodejsUpdatedConstraintsMigration.relationUniques) { _%>
+      { relationUniques: <%- nodejsUpdatedConstraintsMigration.relationUniques %> },
+<%_ } _%>
+    );
+    await createForeignKeys(queryRunner, '<%= nodejsUpdatedConstraintsMigration.tableName %>', [
+<%_ for (const foreignKey of nodejsUpdatedConstraintsMigration.addedForeignKeys) { _%>
+      { columnName: '<%= foreignKey.columnName %>', referencedTableName: '<%= foreignKey.referencedTableName %>', referencedColumnName: '<%= foreignKey.referencedColumnName %>' },
+<%_ } _%>
+    ]);
+<%_ } _%>
+<%_ for (const joinTable of nodejsUpdatedConstraintsMigration.addedJoinTables) { _%>
+    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(<%= nodejsUpdatedConstraintsMigration.addedJoinColumnNames || nodejsUpdatedConstraintsMigration.addedJoinTables.length > 0 ? '' : '_' %>queryRunner: QueryRunner): Promise<void> {
+<%_ if (nodejsUpdatedConstraintsMigration.removedJoinColumnNames || nodejsUpdatedConstraintsMigration.removedJoinTables.length > 0) { _%>
+    // The join columns and the join tables of the removed relationships are not restored, nor their values.
+<%_ } _%>
+<%_ for (const joinTable of nodejsUpdatedConstraintsMigration.addedJoinTables) { _%>
+    await queryRunner.dropTable('<%= joinTable.name %>', true);
+<%_ } _%>
+<%_ if (nodejsUpdatedConstraintsMigration.addedJoinColumnNames) { _%>
+    await dropColumns(queryRunner, '<%= nodejsUpdatedConstraintsMigration.tableName %>', <%- nodejsUpdatedConstraintsMigration.addedJoinColumnNames %>);
+<%_ } _%>
+  }
+}

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

@@ -0,0 +1,28 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+import { <%= nodejsUpdatedMigration.schemaImports %> } from './support/schema.ts';
+
+/** Updated the fields of the entity <%= entityClass %>: the columns of its added fields, the ones of its removed fields dropped. */
+export class <%= nodejsUpdatedMigration.className %> implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+<%_ if (nodejsUpdatedMigration.addedColumnNames) { _%>
+    await addColumns(queryRunner, '<%= nodejsUpdatedMigration.tableName %>', [
+<%_ for (const column of nodejsUpdatedMigration.addedColumns) { _%>
+      { 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.nullable) { %>, nullable: true<% } %><% if (column.unique) { %>, unique: true<% } %> },
+<%_ } _%>
+    ]);
+<%_ } _%>
+<%_ if (nodejsUpdatedMigration.removedColumnNames) { _%>
+    await dropColumns(queryRunner, '<%= nodejsUpdatedMigration.tableName %>', <%- nodejsUpdatedMigration.removedColumnNames %>);
+<%_ } _%>
+  }
+
+  public async down(<%= nodejsUpdatedMigration.addedColumnNames ? '' : '_' %>queryRunner: QueryRunner): Promise<void> {
+<%_ if (nodejsUpdatedMigration.removedColumnNames) { _%>
+    // The columns of the removed fields are not restored, nor their values.
+<%_ } _%>
+<%_ if (nodejsUpdatedMigration.addedColumnNames) { _%>
+    await dropColumns(queryRunner, '<%= nodejsUpdatedMigration.tableName %>', <%- nodejsUpdatedMigration.addedColumnNames %>);
+<%_ } _%>
+  }
+}

package/generators/node-server/index.js

@@ -0,0 +1,2 @@
+export { default } from './generator.js';
+export { default as command } from './command.js';

package/generators/node-server/resources/package.json

@@ -0,0 +1,76 @@
+{
+  "dependencies": {
+    "@nestjs-modules/mailer": "3.0.2",
+    "@nestjs/axios": "12.0.1",
+    "@nestjs/common": "12.2.0",
+    "@nestjs/config": "12.0.1",
+    "@nestjs/core": "12.2.0",
+    "@nestjs/jwt": "12.0.3",
+    "@nestjs/passport": "12.0.0",
+    "@nestjs/platform-express": "12.2.0",
+    "@nestjs/schedule": "12.0.2",
+    "@nestjs/serve-static": "12.0.0",
+    "@nestjs/swagger": "12.0.4",
+    "@nestjs/terminus": "12.1.0",
+    "@nestjs/typeorm": "12.0.2",
+    "@rocketsoftware/eureka-js-client": "4.5.9",
+    "bcrypt": "6.0.0",
+    "better-sqlite3": "13.0.3",
+    "class-transformer": "0.5.1",
+    "class-validator": "0.15.1",
+    "cloud-config-client": "1.6.2",
+    "consul": "2.0.1",
+    "dotenv": "18.0.9",
+    "express": "5.3.0",
+    "express-session": "1.19.0",
+    "handlebars": "4.7.10",
+    "js-yaml": "5.5.0",
+    "jwks-rsa": "4.1.0",
+    "jwt-decode": "4.0.0",
+    "mongodb": "7.7.0",
+    "mongodb-memory-server": "11.3.0",
+    "mssql": "12.7.13",
+    "mysql2": "3.24.6",
+    "oracledb": "7.0.1",
+    "passport": "0.7.0",
+    "passport-jwt": "4.0.1",
+    "passport-oauth2": "1.8.0",
+    "pg": "8.23.1",
+    "prom-client": "15.1.3",
+    "qs": "6.16.1",
+    "reflect-metadata": "0.2.2",
+    "rxjs": "7.8.2",
+    "swagger-ui-express": "5.0.1",
+    "typeorm": "1.1.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "10.0.1",
+    "@nestjs/cli": "12.0.10",
+    "@nestjs/schematics": "12.0.9",
+    "@nestjs/testing": "12.2.0",
+    "@types/bcrypt": "6.0.0",
+    "@types/express": "5.0.6",
+    "@types/express-serve-static-core": "5.1.3",
+    "@types/express-session": "1.19.0",
+    "@types/node": "24.19.2",
+    "@types/passport": "1.0.17",
+    "@types/passport-jwt": "4.0.1",
+    "@types/passport-oauth2": "1.8.0",
+    "@types/qs": "6.15.1",
+    "@types/superagent": "8.1.11",
+    "@types/supertest": "7.2.1",
+    "@vitest/coverage-v8": "5.0.5",
+    "eslint": "10.13.0",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-prettier": "5.5.7",
+    "globals": "17.13.0",
+    "rimraf": "5.0.10",
+    "sonarqube-scanner": "5.0.2",
+    "supertest": "7.3.1",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.72.1",
+    "vite": "8.3.5",
+    "vitest": "5.0.5"
+  },
+  "packageManager": "npm@11"
+}

package/generators/node-server/support/api-fake-data.js

@@ -0,0 +1,54 @@
+/**
+ * The fake values of the fields of an entity as the API exchanges them, the values of the JSON of JHipster Spring Boot,
+ * for the tests storing an entity in the database and reading it back.
+ */
+
+/** The value of a field in a request and in the response reading it back. */
+export const apiFakeValue = field => {
+  // An ISO-8601 duration (PT10M), the JSON of a Duration of JHipster Spring Boot.
+  if (field.fieldType === 'Duration') return field.generateFakeData('cypress');
+  const value = field.generateFakeData('json-serializable');
+  // The text of a TextBlob, a String of JHipster Spring Boot: json-serializable gives the base64 of any byte[].
+  if (field.fieldTypeBlobContent === 'text' && typeof value === 'string') return Buffer.from(value, 'base64').toString();
+  // Seconds without milliseconds: the datetime columns of MySQL do not keep them.
+  if (value instanceof Date) return `${value.toISOString().slice(0, 19)}.000Z`;
+  return value;
+};
+
+/** The content type of a binary blob, like the JHipster clients send it. */
+const contentTypeOf = field => (field.fieldTypeBlobContent === 'image' ? 'image/png' : 'application/octet-stream');
+
+/**
+ * The values of the fields of an entity in a request (and their content types), and the fields compared approximately:
+ * a Float is a single precision number of some databases (MySQL).
+ */
+export const apiFakeEntity = entity => {
+  const values = {};
+  for (const field of entity.fields.filter(field => !field.id && !field.transient && !field.autoGenerate)) {
+    const value = apiFakeValue(field);
+    if (value === undefined || value === null) continue;
+    values[field.fieldName] = value;
+    if (['byte[]', 'ByteBuffer'].includes(field.fieldType) && field.fieldTypeBlobContent !== 'text') {
+      values[`${field.fieldName}ContentType`] = contentTypeOf(field);
+    }
+  }
+  const approximateFields = entity.fields
+    .filter(field => field.fieldType === 'Float' && field.fieldName in values)
+    .map(field => field.fieldName);
+  return { values, approximateFields };
+};
+
+/**
+ * The mutations of a relationship of an entity: the values of the related record its relationship test of the database
+ * end-to-end tests posts, as the API exchanges them, drawn with a seed of that test. JHipster keeps the unique values of a
+ * field for the whole generation: the same seed in every test would draw them again, until a unique field is left without
+ * one (from the fifth relationship to the same entity).
+ */
+export const mutateRelatedValues = entity => ({
+  __override__: false,
+  nodejsRelatedValues: ({ otherEntity, propertyName }) => {
+    if (otherEntity.builtIn) return undefined;
+    otherEntity.resetFakerSeed(`nodejs-database-e2e-${entity.entityInstance}-${propertyName}`);
+    return apiFakeEntity(otherEntity).values;
+  },
+});

package/generators/node-server/support/columns.js

@@ -0,0 +1,73 @@
+/** The precision and the scale of a BigDecimal column of JHipster Spring Boot (decimal(21,2)). */
+export const bigDecimalPrecision = { precision: 21, scale: 2 };
+
+/**
+ * The transformer of the column of a field (src/common/database/column-transformers.ts), so the API gives the values of the
+ * JSON of JHipster Spring Boot whatever the SQL database: undefined when the driver gives them already.
+ * - number: a bigint or a decimal, which the PostgreSQL and MySQL drivers give as a string;
+ * - duration: the nanoseconds of a bigint column, an ISO-8601 duration (PT1H30M) in the API;
+ * - blob: a blob column, which the drivers give as a Buffer, the base64 or text string the API received.
+ */
+export const columnTransformer = ({ fieldType, nodejsColumnType }) => {
+  if (fieldType === 'Duration') return 'duration';
+  if (['Long', 'BigDecimal'].includes(fieldType)) return 'number';
+  if (nodejsColumnType === 'blob') return 'blob';
+  return undefined;
+};
+
+/**
+ * The databases with column types of JHipster Spring Boot better-sqlite3 (dev and test) has not, chosen at runtime by
+ * src/common/database/column-types.ts: the long blobs and texts and the microseconds of MySQL and MariaDB.
+ */
+const runtimeColumnTypeDatabases = ['mysql', 'mariadb'];
+
+/** Whether the columns of an application get their types at runtime (see runtimeColumnTypeDatabases). */
+export const hasRuntimeColumnTypes = ({ databaseTypeSql, prodDatabaseType }) =>
+  Boolean(databaseTypeSql) && runtimeColumnTypeDatabases.includes(prodDatabaseType);
+
+/** Whether the column of a field has a type chosen at runtime: a blob, a text, or the precision of an instant. */
+const runtimeColumnType = field => ['blob', 'text'].includes(field.nodejsColumnType);
+const runtimeDatetimePrecision = field => ['Instant', 'ZonedDateTime'].includes(field.fieldType);
+
+/** The helpers of src/common/database/column-types.ts the @Column decorator of a field uses. */
+export const fieldColumnTypeImports = (field, application) => {
+  if (!hasRuntimeColumnTypes(application)) return [];
+  return [runtimeColumnType(field) && 'columnType', runtimeDatetimePrecision(field) && 'datetimePrecision'].filter(Boolean);
+};
+
+/**
+ * The options of the @Column decorator of a field. A MongoDB column has no name: TypeORM writes the documents by the names
+ * of the properties and reads them by the names of the columns, so a document would be read without its fields.
+ */
+export const fieldColumnOptions = (field, application) => {
+  const { databaseTypeSql } = application;
+  const { fieldValidationRequired: required, fieldValidationUnique: unique, fieldValidationMaxlength: maxlength } = field;
+  const runtime = hasRuntimeColumnTypes(application);
+  const options = [];
+  if (field.nodejsColumnType) {
+    options.push(
+      runtime && runtimeColumnType(field) ? `type: columnType('${field.nodejsColumnType}')` : `type: '${field.nodejsColumnType}'`,
+    );
+  }
+  if (runtime && runtimeDatetimePrecision(field)) options.push('precision: datetimePrecision()');
+  if (databaseTypeSql) options.push(`name: '${field.fieldNameAsDatabaseColumn}'`);
+  if (field.fieldIsEnum) {
+    options.push(`enum: ${field.fieldType}`);
+  } else if (field.fieldType === 'BigDecimal') {
+    options.push(`precision: ${bigDecimalPrecision.precision}`, `scale: ${bigDecimalPrecision.scale}`);
+  } else if (!['Instant', 'ZonedDateTime', 'LocalDate'].includes(field.fieldType) && maxlength) {
+    options.push(`length: ${field.fieldValidateRulesMaxlength}`);
+  }
+  if (!required) options.push('nullable: true');
+  if (unique) options.push('unique: true');
+  if (field.nodejsColumnTransformer) options.push(`transformer: ${field.nodejsColumnTransformer}Transformer`);
+  return options;
+};
+
+/** The options of the @Column decorator of the content type of a binary blob. */
+export const contentTypeColumnOptions = (field, { databaseTypeSql }) => {
+  return [
+    databaseTypeSql && `name: '${field.fieldNameAsDatabaseColumn}_content_type'`,
+    !field.fieldValidationRequired && 'nullable: true',
+  ].filter(Boolean);
+};