@mshima/generator-jhipster-nodejs 0.0.1 → 0.0.2

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

@@ -23,19 +23,4 @@ export const entityFiles = {
       ],
     },
   ],
-  // The migrations of the entity, like its Liquibase changelogs: its table, then its constraints when it has some.
-  migrations: [
-    {
-      path: SERVER_NODEJS_DIR,
-      condition: ctx => ctx.databaseTypeSql,
-      renameTo: data => `${SERVER_NODEJS_DIR}src/migrations/${data.nodejsMigration.fileName}.ts`,
-      templates: ['src/migrations/_entityMigration_.ts'],
-    },
-    {
-      path: SERVER_NODEJS_DIR,
-      condition: ctx => ctx.databaseTypeSql && ctx.nodejsConstraintsMigration,
-      renameTo: data => `${SERVER_NODEJS_DIR}src/migrations/${data.nodejsConstraintsMigration.fileName}.ts`,
-      templates: ['src/migrations/_entityConstraintsMigration_.ts'],
-    },
-  ],
 };

package/generators/node-server/generator.js

@@ -16,9 +16,7 @@ import {
   apiFakeEntity,
   apiFakeValue,
   columnTransformer,
-  constraintsMigration,
   contentTypeColumnOptions,
-  entityMigration,
   fieldColumnOptions,
   fieldColumnTypeImports,
   fieldTypeValidators,
@@ -225,6 +223,12 @@ export default class extends BaseApplicationGenerator {
       async composingTemplateTask() {
         await this.composeWithJHipster('docker');
       },
+      async composeMigrations() {
+        // The migrations of the entities of a SQL database, from their changelogs, like the incremental Liquibase changelogs.
+        if (this.jhipsterConfigWithDefaults.databaseType === 'sql') {
+          await this.composeWithJHipster('jhipster-nodejs:node-server:migrations');
+        }
+      },
       async composeLanguages() {
         // Like the spring-boot generator: the languages of the application to generate (languagesToGenerate), the server
         // messages of server:i18n among them, without a client composing it.
@@ -434,9 +438,8 @@ export default class extends BaseApplicationGenerator {
           application.nodejsUserPrimaryKeyColumn = primaryKeyColumn(application.user);
           application.nodejsUserAuthorityJoinTable = userAuthorityJoinTable(application);
         }
+        // The migrations of the entities are the ones of their changelogs (the migrations generator).
         for (const entity of entities.filter(entity => !entity.skipServer && !entity.builtIn)) {
-          entity.nodejsMigration = entityMigration(entity);
-          entity.nodejsConstraintsMigration = constraintsMigration(entity);
           // The join tables of the entity, its @JoinTable the same as its constraints migration.
           for (const relationship of entity.relationships.filter(relationship => relationship.shouldWriteJoinTable)) {
             relationship.nodejsJoinTable = joinTable(entity, relationship);
@@ -476,7 +479,7 @@ export default class extends BaseApplicationGenerator {
                 'server/src/migrations/1570200490072-SeedUsersRoles.ts',
               ],
             ],
-            '4.3.1': [
+            '4.2.1': [
               // The HTTP helpers of the server moved from src/client (a name taken by the client workspace) to src/common.
               'server/src/client/header-util.ts',
               'server/src/client/request.ts',
@@ -487,6 +490,9 @@ export default class extends BaseApplicationGenerator {
               'server/webpack.server.prod.config.js',
               // The Nest CLI builds and starts the server, and copies the configuration files (assets of nest-cli.json).
               'server/scripts/copy-resources.ts',
+              // The development profile of 4.2.0 (BACKEND_ENV=dev) is in .env.dev: the .env file, loaded by every start of the
+              // server, would start the built server with the development profile.
+              'server/.env',
               // The files of 4.2.0 moved to the feature modules (auth, users, management, common), their specs next to them.
               'server/src/domain/authority.entity.ts',
               'server/src/domain/user.entity.ts',
@@ -574,7 +580,7 @@ export default class extends BaseApplicationGenerator {
           await control.cleanupFiles(this.oldNodejsVersion, {
             '3.0.1': entities.filter(e => !e.skipServer).map(e => `server/src/repository/${e.entityFileName}.repository.ts`),
             // The files of the entities, of 4.2.0, moved to their feature module (src/entities/<entity>).
-            '4.3.1': entities
+            '4.2.1': entities
               .filter(entity => !entity.skipServer && !entity.builtIn)
               .flatMap(({ entityFileName, fields }) => [
                 `server/src/domain/${entityFileName}.entity.ts`,
@@ -692,9 +698,6 @@ export default class extends BaseApplicationGenerator {
           if (!entity.builtIn) {
             source.addEntityToAppModule({ nodejsModulePath, entityClass });
           }
-          for (const migration of [entity.nodejsMigration, entity.nodejsConstraintsMigration].filter(Boolean)) {
-            source.addMigrationToNodeConfig(migration);
-          }
         }
       },
     });

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

@@ -75,7 +75,8 @@ export default class extends BaseApplicationGenerator {
     return this.asDefaultTaskGroup({
       postPreparing({ application }) {
         if (application.authority) {
-          application.authority.skipClient = !application.clientFrameworkAngular;
+          // 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/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/_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/resources/package.json

@@ -29,7 +29,7 @@
     "jwt-decode": "4.0.0",
     "mongodb": "7.7.0",
     "mongodb-memory-server": "11.3.0",
-    "mssql": "12.7.11",
+    "mssql": "12.7.13",
     "mysql2": "3.24.6",
     "oracledb": "7.0.1",
     "passport": "0.7.0",
@@ -68,7 +68,7 @@
     "sonarqube-scanner": "5.0.2",
     "supertest": "7.3.1",
     "typescript": "6.0.3",
-    "typescript-eslint": "8.72.0",
+    "typescript-eslint": "8.72.1",
     "vite": "8.3.5",
     "vitest": "5.0.5"
   },

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

@@ -13,6 +13,14 @@ import { serverEnumInfo } from './enums.js';
  * the timestamp of the changelogDate of their entity, the changelogs of the constraints the ones of the constraints at
  * that timestamp plus CONSTRAINTS_TIMESTAMP_OFFSET, and the changelogs of the developers, at the end of master.xml, the
  * migrations the typeorm:migration scripts create at their time plus MIGRATION_TIMESTAMP_OFFSET.
+ *
+ * Like the incremental changelogs of Liquibase, the migrations of an entity are the ones of its changelogs JHipster records
+ * (jhipster:base-application:database-changelogs, the changelog objects of the .yo-rc.json): its creation, AddedEntity
+ * and AddedEntityConstraints, then each update at the date of its changelog plus MIGRATION_TIMESTAMP_OFFSET (after the
+ * constraints, like the incremental changelogs at the end of master.xml): UpdatedEntity adds the columns of the added
+ * fields and drops the ones of the removed fields, then UpdatedEntityConstraints, 1 ms after, adds and drops the join
+ * columns, their foreign keys and the join tables of the relationships. A migration is written once, by the generation
+ * recording its changelog.
  */
 
 /**
@@ -33,6 +41,22 @@ export const MIGRATION_TIMESTAMP_OFFSET = 6 * 10 ** 12;
 /** The JavaScript timestamp (milliseconds, UTC) of the changelogDate of an entity, the date JHipster parses it to. */
 const entityTimestamp = entity => entity.changelogDateForRecent.getTime();
 
+/** The JavaScript timestamp (milliseconds, UTC) of a changelogDate of JHipster (yyyyMMddHHmmss). */
+export const changelogDateToTimestamp = changelogDate => {
+  const [, year, month, day, hours, minutes, seconds] = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})$/.exec(changelogDate) ?? [];
+  if (!year) {
+    throw new Error(`The changelogDate ${changelogDate} is not a date of the yyyyMMddHHmmss format`);
+  }
+  return Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hours), Number(minutes), Number(seconds));
+};
+
+/** The class and the file of a migration of an entity, by the kind of the migration and its timestamp. */
+const migrationName = (kind, entityClass, timestamp) => ({
+  timestamp,
+  className: `${kind}${entityClass}${timestamp}`,
+  fileName: `${timestamp}-${kind}${entityClass}`,
+});
+
 /** The TypeScript of the type of a column whose @Column decorator has none: the TypeScript type of its property. */
 const typeOfFieldType = {
   string: 'String',
@@ -75,12 +99,15 @@ export const fieldColumns = field => {
     column.length = field.fieldValidateRulesMaxlength;
   }
   const columns = [column];
-  if (['byte[]', 'ByteBuffer'].includes(field.fieldType) && field.fieldTypeBlobContent !== 'text') {
+  if (hasContentTypeColumn(field)) {
     columns.push({ name: `${field.fieldNameAsDatabaseColumn}_content_type`, type: 'String', nullable });
   }
   return columns;
 };
 
+/** Whether a field is a binary blob, stored with the column of its content type. */
+const hasContentTypeColumn = field => ['byte[]', 'ByteBuffer'].includes(field.fieldType) && field.fieldTypeBlobContent !== 'text';
+
 /**
  * The camelCase of the default naming strategy of TypeORM, the names it gives the join columns and the columns of the join
  * tables: unlike the one of lodash, it keeps the case of the letters it does not join (mainURL_id is mainURLId).
@@ -131,14 +158,11 @@ export const joinTable = (entity, relationship) => {
   };
 };
 
-/** The migration adding the table of an entity, its name, its class and its columns. */
-export const entityMigration = entity => {
-  const timestamp = entityTimestamp(entity);
+/** The migration adding the table of an entity, its name, its class and its columns, at the timestamp of its creation. */
+export const entityMigration = (entity, timestamp = entityTimestamp(entity)) => {
   const relationships = joinColumnRelationships(entity);
   return {
-    timestamp,
-    className: `AddedEntity${entity.entityClass}${timestamp}`,
-    fileName: `${timestamp}-AddedEntity${entity.entityClass}`,
+    ...migrationName('AddedEntity', entity.entityClass, timestamp),
     tableName: entity.entityTableName,
     columns: [
       primaryKeyColumn(entity),
@@ -158,25 +182,180 @@ export const entityMigration = entity => {
  * The migration adding the constraints of an entity, its foreign keys and its join tables, when it has some: run after the
  * migrations of every table, like the constraints changelogs of JHipster run after every table.
  */
-export const constraintsMigration = entity => {
+export const constraintsMigration = (entity, timestamp = entityTimestamp(entity)) => {
   const joinColumns = joinColumnRelationships(entity);
   const joinTables = joinTableRelationships(entity);
   if (joinColumns.length === 0 && joinTables.length === 0) return undefined;
-  const timestamp = entityTimestamp(entity) + CONSTRAINTS_TIMESTAMP_OFFSET;
   return {
-    timestamp,
-    className: `AddedEntityConstraints${entity.entityClass}${timestamp}`,
-    fileName: `${timestamp}-AddedEntityConstraints${entity.entityClass}`,
+    ...migrationName('AddedEntityConstraints', entity.entityClass, timestamp + CONSTRAINTS_TIMESTAMP_OFFSET),
     tableName: entity.entityTableName,
-    foreignKeys: joinColumns.map(relationship => ({
-      columnName: joinColumnName(relationship),
-      referencedTableName: relationship.otherEntity.entityTableName,
-      referencedColumnName: relationship.otherEntity.primaryKey.name,
-    })),
+    foreignKeys: joinColumns.map(foreignKey),
     joinTables: joinTables.map(relationship => joinTable(entity, relationship)),
   };
 };
 
+/** The foreign key of the join column of a relationship. */
+const foreignKey = relationship => ({
+  columnName: joinColumnName(relationship),
+  referencedTableName: relationship.otherEntity.entityTableName,
+  referencedColumnName: relationship.otherEntity.primaryKey.name,
+});
+
+/**
+ * The migrations of a changelog of an entity, of this generation: for its creation the table of the entity at its date
+ * (nodejsMigration), then its constraints (nodejsConstraintsMigration); for an update its fields (nodejsUpdatedMigration),
+ * then its relationships (nodejsUpdatedConstraintsMigration), after the constraints of every entity; for its removal its
+ * join tables and its table (nodejsRemovedMigration), after the updates of the entities whose relationships referenced it.
+ * @param {any} changelog the changelog
+ * @param {any} entity the entity, prepared: none for a removal
+ * @param {any[]} entities the entities of the application, prepared
+ */
+export const changelogMigrations = (changelog, entity, entities) => {
+  const timestamp = changelogDateToTimestamp(changelog.changelogDate);
+  if (changelog.operation === 'create') {
+    return { nodejsMigration: entityMigration(entity, timestamp), nodejsConstraintsMigration: constraintsMigration(entity, timestamp) };
+  }
+  if (changelog.operation === 'update') {
+    const changes = { entity, ...changelogChanges(changelog, entity, entities) };
+    return {
+      nodejsUpdatedMigration: updatedEntityMigration(changes, timestamp + MIGRATION_TIMESTAMP_OFFSET),
+      // The relationships after the fields, whose join columns may reference them.
+      nodejsUpdatedConstraintsMigration: updatedConstraintsMigration(changes, timestamp + MIGRATION_TIMESTAMP_OFFSET + 1),
+    };
+  }
+  return { nodejsRemovedMigration: removedEntityMigration(changelog, timestamp + MIGRATION_TIMESTAMP_OFFSET) };
+};
+
+/**
+ * The migration of the removal of an entity, like the dropTable of Liquibase: the join tables it owned, then its table, from
+ * the entity before the changelog (its previousEntity). The relationships of the other entities referencing it are removed
+ * with it, their join columns and their join tables dropped by their update migrations, dated before.
+ * @param {any} changelog the removal changelog of this generation
+ * @param {number} timestamp the timestamp of the migration
+ */
+export const removedEntityMigration = ({ entityName, previousEntity }, timestamp) => ({
+  ...migrationName('RemovedEntity', `${entityName.charAt(0).toUpperCase()}${entityName.slice(1)}`, timestamp),
+  entityName,
+  tableName: previousEntity.entityTableName,
+  joinTables: previousEntity.relationships.filter(hasJoinTable).map(relationship => relationship.joinTable.name),
+});
+
+/** The class of a migration, by the name of its file (`<timestamp>-<kind><Entity>`, its class `<kind><Entity><timestamp>`). */
+export const migrationOfFile = fileName => ({ fileName, className: fileName.replace(/^(\d+)-(\w+)$/, '$2$1') });
+
+/**
+ * The fields and the relationships an update changelog of an entity adds and removes: the added ones the entity has,
+ * prepared; the removed ones the entity before the changelog has (its previousEntity, of this generation only), by the
+ * names of their columns. A relationship changed in its type, its other entity, its side or its join column
+ * (recreatedRelationships) is removed and added again; one changed in its options only (onDelete, onUpdate), which the
+ * foreign keys of the server do not declare, is left alone. A field changed (its type, its validations) is not migrated.
+ * @param {any} changelog the update changelog of this generation
+ * @param {any} entity the entity, prepared
+ * @param {any[]} entities the entities of the application, prepared
+ */
+export const changelogChanges = (changelog, entity, entities) => {
+  const { previousEntity, recreatedRelationships } = changelog;
+  const named = (items, names, key) => items.filter(item => names.includes(item[key]));
+  return {
+    addedFields: named(entity.fields, changelog.addedFields, 'fieldName'),
+    removedFields: named(previousEntity.fields, changelog.removedFields, 'fieldName'),
+    addedRelationships: named(entity.relationships, [...changelog.addedRelationships, ...recreatedRelationships], 'relationshipName'),
+    removedRelationships: named(
+      previousEntity.relationships,
+      [...changelog.removedRelationships, ...recreatedRelationships],
+      'relationshipName',
+    ).map(relationship => removedRelationship(relationship, entities)),
+  };
+};
+
+/**
+ * A relationship of the entity before a changelog, as the changelog records it (its type, its side, its other entity and its
+ * join table), with the properties of a relationship the migrations name its join column by: its field, and the primary key
+ * of its other entity (id when the other entity is no longer).
+ */
+const removedRelationship = (relationship, entities) => {
+  const otherEntity = entities.find(entity => entity.name.toLowerCase() === relationship.otherEntityName.toLowerCase());
+  return {
+    ...relationship,
+    relationshipFieldName: `${relationship.relationshipName.charAt(0).toLowerCase()}${relationship.relationshipName.slice(1)}`,
+    otherEntity: otherEntity ?? { primaryKey: { name: 'id' } },
+  };
+};
+
+/** The names of the columns of a field of the entity before a changelog, by the column name the changelog records. */
+const removedFieldColumnNames = field => [field.columnName, ...(hasContentTypeColumn(field) ? [`${field.columnName}_content_type`] : [])];
+
+/** The TypeScript of an array of names, none without a name. */
+const namesLiteral = names => (names.length > 0 ? `[${names.map(literal).join(', ')}]` : undefined);
+
+/**
+ * The migration of the fields of an entity an update changelog changes, like the updated_entity changelog of Liquibase: the
+ * columns of the added fields, and the names of the columns of the removed fields. None without an added or a removed field.
+ * @param {{ entity: any, addedFields: any[], removedFields: any[] }} changes the changes of the changelog (changelogChanges)
+ * @param {number} timestamp the timestamp of the migration
+ */
+export const updatedEntityMigration = ({ entity, addedFields, removedFields }, timestamp) => {
+  if (addedFields.length === 0 && removedFields.length === 0) return undefined;
+  const addedColumns = addedFields.flatMap(fieldColumns);
+  return {
+    ...migrationName('UpdatedEntity', entity.entityClass, timestamp),
+    tableName: entity.entityTableName,
+    addedColumns,
+    // The TypeScript of the names of the columns the migration adds and drops, and of the helpers it imports.
+    addedColumnNames: namesLiteral(addedColumns.map(column => column.name)),
+    removedColumnNames: namesLiteral(removedFields.flatMap(removedFieldColumnNames)),
+    schemaImports: addedColumns.length > 0 ? 'addColumns, dropColumns' : 'dropColumns',
+  };
+};
+
+/** Whether a relationship has a join column: a many-to-one one, or a one-to-one one on its owner side. */
+const hasJoinColumn = ({ relationshipType, ownerSide }) =>
+  relationshipType === 'many-to-one' || (relationshipType === 'one-to-one' && ownerSide);
+
+/** Whether a relationship has a join table: a many-to-many one on its owner side. */
+const hasJoinTable = ({ relationshipType, ownerSide }) => relationshipType === 'many-to-many' && ownerSide;
+
+/**
+ * The migration of the relationships of an entity an update changelog changes, like the updated_entity_constraints changelog
+ * of Liquibase: the join columns with their foreign keys and the join tables of the added relationships, and the ones of
+ * the removed relationships dropped. None without a join column or a join table added or removed.
+ * @param {{ entity: any, addedRelationships: any[], removedRelationships: any[] }} changes the changes of the changelog (changelogChanges)
+ * @param {number} timestamp the timestamp of the migration
+ */
+export const updatedConstraintsMigration = ({ entity, addedRelationships, removedRelationships }, timestamp) => {
+  const addedJoinColumns = addedRelationships.filter(hasJoinColumn);
+  const changes = {
+    addedJoinColumns: addedJoinColumns.map(relationship => ({
+      ...referenceColumn(joinColumnName(relationship), relationship.otherEntity),
+      nullable: true,
+    })),
+    addedForeignKeys: addedJoinColumns.map(foreignKey),
+    addedJoinTables: addedRelationships.filter(hasJoinTable).map(relationship => joinTable(entity, relationship)),
+    removedJoinColumns: removedRelationships.filter(hasJoinColumn).map(joinColumnName),
+    removedJoinTables: removedRelationships.filter(hasJoinTable).map(relationship => relationship.joinTable.name),
+  };
+  if (Object.values(changes).every(list => list.length === 0)) return undefined;
+  return {
+    ...migrationName('UpdatedEntityConstraints', entity.entityClass, timestamp),
+    tableName: entity.entityTableName,
+    ...changes,
+    // The TypeScript of the names of the join columns, of the unique ones of the one-to-one relationships, and of the helpers
+    // the migration imports.
+    addedJoinColumnNames: namesLiteral(changes.addedJoinColumns.map(column => column.name)),
+    relationUniques: namesLiteral(
+      addedJoinColumns.filter(relationship => relationship.relationshipType === 'one-to-one').map(joinColumnName),
+    ),
+    removedJoinColumnNames: namesLiteral(changes.removedJoinColumns),
+    schemaImports: [
+      addedJoinColumns.length > 0 && 'addColumns, createForeignKeys',
+      changes.addedJoinTables.length > 0 && 'createJoinTable',
+      (addedJoinColumns.length > 0 || changes.removedJoinColumns.length > 0) && 'dropColumns',
+    ]
+      .filter(Boolean)
+      .join(', '),
+  };
+};
+
 /**
  * The join table of the authorities of the built-in users, named like TypeORM names the junction table of the @JoinTable()
  * of User.authorities: the tables and the property, its columns the tables and their primary keys.

package/generators/node-server/templates/package.json.ejs

@@ -65,8 +65,6 @@
     "docker:build": "docker build -t <%= baseName.toLowerCase() %> .",
     "lint": "<%= clientPackageManager %> run lint --workspaces",
     "lint:fix": "<%= clientPackageManager %> run lint:fix --workspaces",
-    "prettier:check": "prettier --check \"{,src/**/}*.{<%= prettierExtensions %>}\"",
-    "prettier:format": "prettier --write \"{,src/**/}*.{<%= prettierExtensions %>}\"",
 <%_ if (clientFrameworkAny) { _%>
     "start": "concurrently -k -s first -n application,client -c red,green npm:start:server npm:start:client",
 <%_ } else { _%>

package/generators/node-server/templates/server/README.md.ejs

@@ -103,11 +103,19 @@ creates the tables of the users and of the authorities, then each entity has the
 (`<timestamp>-AddedEntity<Entity>.ts`, the timestamp of its `changelogDate`) and, when it has relationships, the one adding
 its foreign keys and its join tables (`<timestamp>-AddedEntityConstraints<Entity>.ts`, its timestamp plus 3000000000000),
 run after the tables of every entity, like the constraints changelogs of Liquibase. A database the application ran them
-on already is not changed by a regeneration of a migration: when an entity changes, add the migration of the change
-(`npm run typeorm:migration:generate`) or recreate the development database. Like the Liquibase changelogs without
-incremental changelogs, a regeneration rewrites the migrations of the entity changed (a new column in the migration of its
-table): restore the migrations a database ran already (`git restore src/migrations`), keeping the entities, before
-generating the migration of the change, so an empty database runs them all.
+on already is not changed by a regeneration of a migration.
+
+Like the incremental changelogs of Liquibase, a regeneration keeps the migrations of an entity and generates the ones of
+its changes since, run after the others (their timestamp plus <%= nodejsMigrationTimestampOffset %>):
+`<timestamp>-UpdatedEntity<Entity>.ts` adds the columns of the added fields and drops the ones of the removed fields,
+then `<timestamp>-UpdatedEntityConstraints<Entity>.ts` adds and drops the join columns, their foreign keys and the join
+tables of the relationships, and `<timestamp>-RemovedEntity<Entity>.ts` drops the join tables and the table of a removed
+entity, after the updates of the entities whose relationships referenced it. The changes are the changelogs JHipster
+records in the `objects` of `.yo-rc.json`, one for each change of the database schema of an entity: keep them with the
+migrations, the migrations of the application are the ones of its changelogs. A field changed (its type, its
+validations) and a table renamed are not migrated, a dropped column or table keeps none of its values, and a required
+field added to a table having rows needs a migration of your own giving them a value
+(`npm run typeorm:migration:generate`).
 
 The application runs the migrations [src/orm.config.ts](src/orm.config.ts) lists: import the class of a migration of
 your own and add it to `migrations`, so the application runs it at startup, like the ones JHipster adds. The

package/generators/node-server/templates/server/e2e/session.e2e-spec.ts.ejs

@@ -121,9 +121,14 @@ describe('Session authentication', () => {
   });
 
   it('logs in the user of the login, in lower case, in a session of 30 minutes without requests', async () => {
+    const sessions = app.get<Repository<Session>>(getRepositoryToken(Session));
     const response = await login({ username: 'Session-User', password, 'remember-me': 'false' });
     expect(response.status).toBe(200);
-    expect(cookieExpiry(response, 'JSESSIONID')).toBeLessThanOrEqual(Date.now() + 30 * 60 * 1000);
+    // Like the JSESSIONID of JHipster Spring Boot, a cookie until the browser is closed: the session expires on the server.
+    expect(setCookie(response, 'JSESSIONID')).not.toMatch(/Expires|Max-Age/);
+    expect(setCookie(response, 'XSRF-TOKEN')).not.toMatch(/Expires|Max-Age/);
+    const [stored] = await sessions.find({ where: { login: 'session-user' } });
+    expect(stored.expires.getTime()).toBeLessThanOrEqual(Date.now() + 30 * 60 * 1000);
     const { body } = await agent.get('/api/account').expect(200);
     expect(body).toMatchObject({ login: 'session-user' });
     expect(body.password).toBeUndefined();
@@ -158,7 +163,17 @@ describe('Session authentication', () => {
     const response = await login({ username: 'session-user', password, 'remember-me': 'true' });
     expect(response.status).toBe(200);
     expect(cookieExpiry(response, 'JSESSIONID')).toBeGreaterThan(Date.now() + 30 * 24 * 60 * 60 * 1000);
-    expect(cookieExpiry(response, 'XSRF-TOKEN')).toBeGreaterThan(Date.now() + 30 * 24 * 60 * 60 * 1000);
+    // The CSRF cookie lasts until the browser is closed, the next response giving the token of the session again.
+    expect(setCookie(response, 'XSRF-TOKEN')).not.toMatch(/Expires|Max-Age/);
+    const token = cookieValue(response, 'XSRF-TOKEN');
+    const reopened = request(app.getHttpServer()).get('/api/account').set('Cookie', setCookie(response, 'JSESSIONID')!.split(';')[0]);
+    expect(cookieValue(await reopened.expect(200), 'XSRF-TOKEN')).toEqual(token);
+  });
+
+  it('sets no cookie in the responses of a logged session: a response of a session ended by a login meanwhile puts nothing back', async () => {
+    await login({ username: 'session-user', password });
+    const response = await agent.get('/api/account').expect(200);
+    expect(response.headers['set-cookie']).toBeUndefined();
   });
 
   it('refuses the unsafe requests of a session without its CSRF token, the logout included', async () => {

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

@@ -12,7 +12,6 @@ import { HeaderUtil } from './common/header-util.ts';
 import { ProblemDetailsFilter } from './common/errors/problem-details.filter.ts';
 import { ValidationException } from './common/errors/problem.exception.ts';
 <%_ if (authenticationUsesCsrf) { _%>
-import { SESSION_MAX_AGE } from './auth/csrf.middleware.ts';
 import { SessionStore } from './auth/session.store.ts';
 <%_ } _%>
 
@@ -142,9 +141,10 @@ export function configureApp(app: INestApplication): INestApplication {
       store: app.get(SessionStore),
       resave: false,
       saveUninitialized: false,
-      // Like the session of JHipster Spring Boot, it expires after 30 minutes without requests.
-      rolling: true,
-      cookie: { httpOnly: true, sameSite: 'lax', secure: 'auto', maxAge: SESSION_MAX_AGE },
+      // Like the JSESSIONID of JHipster Spring Boot, a cookie until the browser is closed, set when the session is created
+      // only: the session expires on the server, after 30 minutes without requests (SessionStore). A cookie set again by
+      // every response would let a response of a session ended by a login meanwhile put the ended session back.
+      cookie: { httpOnly: true, sameSite: 'lax', secure: 'auto' },
     }),
   );
 <%_ } _%>

package/generators/node-server/templates/server/src/auth/csrf.middleware.spec.ts.ejs

@@ -28,9 +28,13 @@ describe('CsrfMiddleware', () => {
     expect(() => checkLoginCsrfToken({ headers: { cookie: 'SESSION=1; XSRF-TOKEN=t0k', 'x-xsrf-token': 't0k' } } as any)).not.toThrow();
   });
 
-  it('gives the CSRF cookie of a remember-me session its lifetime', () => {
+  it('gives the CSRF cookie of a remember-me session until the browser is closed, like JHipster Spring Boot', () => {
     const { res } = call('GET', { user: { login: 'user' }, csrfToken: 't0k', cookie: { originalMaxAge: 1000 } });
-    expect(res.cookie).toHaveBeenCalledWith('XSRF-TOKEN', 't0k', expect.objectContaining({ maxAge: 1000 }));
+    expect(res.cookie).toHaveBeenCalledWith('XSRF-TOKEN', 't0k', expect.not.objectContaining({ maxAge: expect.anything() }));
+  });
+
+  it('gives a CSRF cookie until the browser is closed to a client without a session, like JHipster Spring Boot', () => {
+    expect(call('GET', {}).res.cookie).toHaveBeenCalledWith('XSRF-TOKEN', expect.any(String), expect.not.objectContaining({ maxAge: expect.anything() }));
   });
 <%_ } else { _%>
   it('lets the requests without a logged session pass, without the cookie', () => {
@@ -40,10 +44,17 @@ describe('CsrfMiddleware', () => {
   });
 <%_ } _%>
 
-  it('gives the token of a logged session back as the XSRF-TOKEN cookie on its safe requests too', () => {
+  it('gives the token of a logged session as the XSRF-TOKEN cookie on its safe requests too, until the browser is closed', () => {
     const { res, next } = call('GET', { user: { login: 'user' }, csrfToken: 't0k' });
     expect(next).toHaveBeenCalled();
-    expect(res.cookie).toHaveBeenCalledWith('XSRF-TOKEN', 't0k', expect.objectContaining({ path: '/', maxAge: expect.any(Number) }));
+    expect(res.cookie).toHaveBeenCalledWith('XSRF-TOKEN', 't0k', expect.objectContaining({ path: '/' }));
+    expect(res.cookie).toHaveBeenCalledWith('XSRF-TOKEN', 't0k', expect.not.objectContaining({ maxAge: expect.anything() }));
+  });
+
+  it('does not set the cookie of a client with the token of its session: a response of a session ended meanwhile puts no old token back', () => {
+    const { res, next } = call('GET', { user: { login: 'user' }, csrfToken: 't0k' }, { cookie: 'JSESSIONID=s1; XSRF-TOKEN=t0k' });
+    expect(next).toHaveBeenCalled();
+    expect(res.cookie).not.toHaveBeenCalled();
   });
 
   it('refuses an unsafe request of a logged session without its token, the logout too, like Spring Security', () => {

package/generators/node-server/templates/server/src/auth/csrf.middleware.ts.ejs

@@ -2,13 +2,15 @@ import { randomUUID } from 'crypto';
 import { ForbiddenException, Injectable, NestMiddleware } from '@nestjs/common';
 import { NextFunction, Request, Response } from 'express';
 
-/** The idle lifetime of a session, rolling: its cookie and the CSRF cookie expire together. */
+/** The idle lifetime of a session, on the server: its cookie lasts until the browser is closed. */
 export const SESSION_MAX_AGE = 30 * 60 * 1000;
 <%_ if (authenticationTypeSession) { _%>
 
 /**
  * The idle lifetime of a session logged in with remember-me, like the validity of the remember-me tokens of JHipster
- * Spring Boot (31 days): kept in the database (SessionStore), the session outlives a restart like those tokens.
+ * Spring Boot (31 days): kept in the database (SessionStore), the session outlives a restart like those tokens. Its
+ * cookie expires 31 days after the login, unlike the remember-me cookie of JHipster Spring Boot, renewed at each new
+ * session it logs in.
  */
 export const REMEMBER_ME_MAX_AGE = 31 * 24 * 60 * 60 * 1000;
 <%_ } _%>
@@ -16,11 +18,13 @@ export const REMEMBER_ME_MAX_AGE = 31 * 24 * 60 * 60 * 1000;
 /** The methods that change nothing, which the CSRF token does not protect, like the ones of Spring Security. */
 const SAFE_METHODS = ['GET', 'HEAD', 'OPTIONS', 'TRACE'];
 
-/** The XSRF-TOKEN cookie the clients (Angular HttpClient, axios) send back as the X-XSRF-TOKEN header. */
-export function setCsrfCookie(res: Response, token: string, maxAge = SESSION_MAX_AGE): void {
-  res.cookie('XSRF-TOKEN', token, { sameSite: 'lax', path: '/', maxAge });
+/**
+ * The XSRF-TOKEN cookie the clients (Angular HttpClient, axios) send back as the X-XSRF-TOKEN header: until the browser is
+ * closed, like the one of JHipster Spring Boot, a remember-me session included.
+ */
+export function setCsrfCookie(res: Response, token: string): void {
+  res.cookie('XSRF-TOKEN', token, { sameSite: 'lax', path: '/' });
 }
-<%_ if (authenticationTypeSession) { _%>
 
 /** The XSRF-TOKEN cookie of a request. */
 function csrfCookie(req: Request): string | undefined {
@@ -30,6 +34,7 @@ function csrfCookie(req: Request): string | undefined {
     .find(value => value.startsWith('XSRF-TOKEN='));
   return cookie ? decodeURIComponent(cookie.slice('XSRF-TOKEN='.length)) : undefined;
 }
+<%_ if (authenticationTypeSession) { _%>
 
 /**
  * The CSRF check of the session login, like the CookieCsrfTokenRepository of Spring Security: the X-XSRF-TOKEN header is
@@ -46,7 +51,7 @@ export function checkLoginCsrfToken(req: Request): void {
 
 /**
  * The CSRF protection of the sessions, like the CSRF filter of Spring Security and the CookieCsrfFilter of JHipster Spring
- * Boot: every response of a logged session gives its token back as the XSRF-TOKEN cookie, and every unsafe request of it,
+ * Boot: a logged session gives its token as the XSRF-TOKEN cookie to a client without it, and every unsafe request of it,
  * the logout included, must send it as X-XSRF-TOKEN, else 403. A request with a bearer token has no session to protect.
 <%_ if (authenticationTypeSession) { _%>
  * A client without a logged session gets a token cookie, which its login must send back (checkLoginCsrfToken).
@@ -66,8 +71,12 @@ export class CsrfMiddleware implements NestMiddleware {
       return;
     }
     session.csrfToken ??= randomUUID();
-    // The CSRF cookie expires with the session cookie<% if (authenticationTypeSession) { %>, later for a remember-me login<% } %>.
-    setCsrfCookie(res, session.csrfToken, session.cookie?.originalMaxAge ?? SESSION_MAX_AGE);
+    if (csrfCookie(req) !== session.csrfToken) {
+      // Like Spring Security, the cookie is set when the client has not the token of its session only (a remember-me
+      // session after the browser is closed): a response of a session ended by a login meanwhile does not put the token
+      // of the ended session back.
+      setCsrfCookie(res, session.csrfToken);
+    }
     if (!SAFE_METHODS.includes(req.method) && req.headers['x-xsrf-token'] !== session.csrfToken) {
       throw new ForbiddenException('Invalid CSRF token');
     }

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

@@ -59,7 +59,7 @@ export class SessionStore extends session.Store implements OnModuleInit, OnModul
   }
 
   touch(sid: string, data: session.SessionData, callback?: Callback): void {
-    // The rolling expiry of a session its request did not change.
+    // 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));
   }
 
@@ -104,7 +104,7 @@ export class SessionStore extends session.Store implements OnModuleInit, OnModul
   }
 }
 
-/** The end of a session: the expiry of its cookie. */
+/** 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);
 }

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

@@ -64,10 +64,10 @@ export class UserSessionController {
     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.
+      // is unused for 31 days (its cookie expires 31 days after the login).
       session.cookie.maxAge = REMEMBER_ME_MAX_AGE;
     }
-    setCsrfCookie(res, session.csrfToken, session.cookie.originalMaxAge);
+    setCsrfCookie(res, session.csrfToken);
     await new Promise<void>((resolve, reject) => session.save((error?: Error) => (error ? reject(error) : resolve())));
   }
 

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

@@ -1,4 +1,4 @@
-import { type ColumnType, type QueryRunner, Table, type TableColumnOptions, TableForeignKey } from 'typeorm';
+import { type ColumnType, type QueryRunner, Table, TableColumn, type TableColumnOptions, TableForeignKey, TableIndex, TableUnique } from 'typeorm';
 import type { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata.js';
 
 import { databaseColumnType, databaseDatetimePrecision } from '../../common/database/column-types.ts';
@@ -111,32 +111,87 @@ export const createTable = async (
   columns: MigrationColumn[],
   options: { relationUniques?: string[] } = {},
 ): Promise<void> => {
+  const { tableColumns, uniques, indices } = uniqueColumns(queryRunner, name, columns, options.relationUniques);
+  await queryRunner.createTable(new Table({ name, columns: tableColumns, uniques, indices }), true);
+};
+
+/**
+ * The columns of a table with their unique constraints, as TypeORM stores them: unique columns, unique constraints or
+ * unique indices, by database.
+ */
+const uniqueColumns = (queryRunner: QueryRunner, tableName: string, columns: MigrationColumn[], relationUniqueColumns: string[] = []) => {
   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]),
+  const relationUniques = relationUniqueColumns.map(columnName => ({
+    name: namingStrategy.relationConstraintName(tableName, [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,
+  return {
+    tableColumns: 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,
+          }))
+        : []),
+    ],
+  };
+};
+
+/** The table of a migration, which the database has. */
+const existingTable = async (queryRunner: QueryRunner, tableName: string): Promise<Table> => {
+  const table = await queryRunner.getTable(tableName);
+  if (!table) {
+    throw new Error(`The table ${tableName} does not exist`);
+  }
+  return table;
+};
+
+/**
+ * Adds the columns of a table missing in the database, like createTable creates them: a database synchronized from the
+ * entities has them already.
+ */
+export const addColumns = async (
+  queryRunner: QueryRunner,
+  tableName: string,
+  columns: MigrationColumn[],
+  options: { relationUniques?: string[] } = {},
+): Promise<void> => {
+  const table = await existingTable(queryRunner, tableName);
+  const missing = columns.filter(column => !table.findColumnByName(column.name));
+  if (missing.length === 0) return;
+  const missingNames = missing.map(column => column.name);
+  const { tableColumns, uniques, indices } = uniqueColumns(
+    queryRunner,
+    tableName,
+    missing,
+    (options.relationUniques ?? []).filter(name => missingNames.includes(name)),
   );
+  await queryRunner.addColumns(table, tableColumns.map(column => new TableColumn(column)));
+  if (uniques.length > 0) {
+    await queryRunner.createUniqueConstraints(tableName, uniques.map(unique => new TableUnique(unique)));
+  }
+  if (indices.length > 0) {
+    await queryRunner.createIndices(tableName, indices.map(index => new TableIndex(index)));
+  }
+};
+
+/** Drops the columns of a table the database has, with their foreign keys. */
+export const dropColumns = async (queryRunner: QueryRunner, tableName: string, columnNames: string[]): Promise<void> => {
+  const table = await existingTable(queryRunner, tableName);
+  const existing = columnNames.filter(name => table.findColumnByName(name));
+  if (existing.length === 0) return;
+  const foreignKeys = table.foreignKeys.filter(foreignKey => foreignKey.columnNames.some(name => existing.includes(name)));
+  if (foreignKeys.length > 0) {
+    await queryRunner.dropForeignKeys(table, foreignKeys);
+  }
+  await queryRunner.dropColumns(tableName, existing);
 };
 
 /**
@@ -144,10 +199,7 @@ export const createTable = async (
  * 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 table = await existingTable(queryRunner, tableName);
   const missing = foreignKeys.filter(
     foreignKey =>
       !table.foreignKeys.some(existing => existing.columnNames.length === 1 && existing.columnNames[0] === foreignKey.columnName),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mshima/generator-jhipster-nodejs",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "A NodeJS blueprint that creates the backend using NodeJS with NestJS framework",
   "keywords": [
     "yeoman-generator",
@@ -55,7 +55,7 @@
   },
   "dependencies": {
     "chalk": "^5.3.0",
-    "generator-jhipster": "npm:@mshima/generator-jhipster@0.0.9"
+    "generator-jhipster": "npm:@mshima/generator-jhipster@0.0.10"
   },
   "devDependencies": {
     "ejs-lint": "2.0.1",