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

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

@@ -0,0 +1,24 @@
+/**
+ * The default port of each production database type of JHipster, the port of its docker service: the database of the
+ * application-dev.yml and application-prod.yml files.
+ */
+export const databasePorts = {
+  postgresql: 5432,
+  mysql: 3306,
+  mariadb: 3306,
+  mssql: 1433,
+  oracle: 1521,
+  mongodb: 27017,
+};
+
+/** The default port of the production database of an application. */
+export const getDatabasePort = ({ databaseType, prodDatabaseType = databaseType }) => databasePorts[prodDatabaseType];
+
+/** The embedded development databases of the NodeJS server: SQLite, on disk or in memory. */
+const embeddedDevDatabaseTypes = ['sqlite', 'sqliteMemory'];
+
+/** The TypeORM type of the development database: better-sqlite3 for an embedded one, else the server type. */
+export const getNodeDevDatabaseType = ({ databaseType, devDatabaseType = databaseType }) => {
+  if (embeddedDevDatabaseTypes.includes(devDatabaseType)) return 'better-sqlite3';
+  return devDatabaseType === 'postgresql' ? 'postgres' : devDatabaseType;
+};

package/generators/node-server/support/entity-authorities.js

@@ -0,0 +1,32 @@
+/**
+ * The roles of the entities, like the @PreAuthorize of the resources of JHipster Spring Boot (entitySpringPreAuthorize and
+ * entitySpringReadPreAuthorize of its spring-boot generator): the roles of entityAuthority (@EntityAuthority of the JDL,
+ * ROLE_ADMIN for an admin entity, like the built-in User and Authority) write and read, the roles of entityReadAuthority
+ * (@EntityReadAuthority) only read. Without them, any authenticated user.
+ */
+
+/** The roles of a comma separated authority of JHipster. */
+const rolesOf = authority =>
+  String(authority ?? '')
+    .split(',')
+    .map(role => role.trim())
+    .filter(Boolean);
+
+/** The TypeScript of the arguments of a @Roles decorator, undefined without roles. */
+const rolesLiteral = roles => (roles.length > 0 ? roles.map(role => `'${role}'`).join(', ') : undefined);
+
+/** The mutations of an entity (entityDefaults), delayed until the entity is prepared. */
+export const mutateEntityAuthorities = {
+  __override__: false,
+  // The roles of the creations, the updates and the deletions.
+  nodejsWriteRoles: ({ entityAuthority }, { delayMarker }) => delayMarker ?? rolesLiteral(rolesOf(entityAuthority)),
+  // The roles of the reads: the ones of the writes and the ones of entityReadAuthority.
+  nodejsReadRoles: ({ entityAuthority, entityReadAuthority }, { delayMarker }) =>
+    delayMarker ?? rolesLiteral([...new Set([...rolesOf(entityAuthority), ...rolesOf(entityReadAuthority)])]),
+  // The roles that only read, which the tests check refused on the writes.
+  nodejsReadOnlyRoles: ({ entityAuthority, entityReadAuthority }, { delayMarker }) => {
+    if (delayMarker) return delayMarker;
+    const writeRoles = rolesOf(entityAuthority);
+    return rolesLiteral(rolesOf(entityReadAuthority).filter(role => !writeRoles.includes(role)));
+  },
+};

package/generators/node-server/support/entity-paths.js

@@ -0,0 +1,13 @@
+/**
+ * The files of an entity, from the src folder of the server, in its feature module: an entity of the JDL in its own folder
+ * of src/entities, the built-in User and Authority in src/users, with the users module.
+ */
+const entityFolder = ({ builtIn, entityFileName }) => (builtIn ? 'users' : `entities/${entityFileName}`);
+
+/** The mutations of an entity (entityDefaults): the paths its imports, its needles and its cleanups use. */
+export const mutateEntityPaths = {
+  __override__: false,
+  nodejsEntityPath: entity => `${entityFolder(entity)}/${entity.entityFileName}.entity.ts`,
+  nodejsDtoPath: entity => `${entityFolder(entity)}/dto/${entity.entityFileName}.dto.ts`,
+  nodejsModulePath: entity => `${entityFolder(entity)}/${entity.entityFileName}.module.ts`,
+};

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

@@ -0,0 +1,11 @@
+import { getEnumInfo } from 'generator-jhipster/generators/base-application/support';
+
+/**
+ * The enum of a field as the server exchanges and stores it, like JHipster Spring Boot: a Java enum is written in JSON
+ * and stored (`@Enumerated(EnumType.STRING)`) by its name, its custom value (`LOW (low_level)`) being only a label of the
+ * client. Each value of the TypeScript enum is its name.
+ */
+export const serverEnumInfo = (field, clientRootFolder) => {
+  const enumInfo = getEnumInfo(field, clientRootFolder);
+  return { ...enumInfo, enumValues: enumInfo.enumValues.map(enumValue => ({ ...enumValue, value: enumValue.name })) };
+};

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

@@ -0,0 +1,9 @@
+export * from './database.js';
+export * from './mail-templates.js';
+export * from './columns.js';
+export * from './api-fake-data.js';
+export * from './migrations.js';
+export * from './entity-paths.js';
+export * from './entity-authorities.js';
+export * from './enums.js';
+export * from './validators.js';

package/generators/node-server/support/mail-templates.js

@@ -0,0 +1,82 @@
+/**
+ * A Thymeleaf expression of the mail templates of JHipster Spring Boot as Handlebars: a message (#{key(${a.b})}) as the
+ * message helper of the server, a variable (${a.b}), a link with literal substitutions (@{|${baseUrl}/path|}), the
+ * language of the mail (${#locale.language}). The variables of a th:with give their converted value.
+ */
+const toHandlebarsValue = (expression, variables) => {
+  const value = expression.trim();
+  if (value === '${#locale.language}') return '{{langKey}}';
+  let match = /^\$\{([\w.]+)\}$/.exec(value);
+  if (match) {
+    return variables[match[1]] ?? `{{${match[1]}}}`;
+  }
+  match = /^#\{([\w.]+)(?:\((.*)\))?\}$/.exec(value);
+  if (match) {
+    const parameters = (match[2] ?? '')
+      .split(',')
+      .map(parameter => parameter.trim())
+      .filter(Boolean)
+      .map(parameter => {
+        const variable = /^\$\{([\w.]+)\}$/.exec(parameter);
+        if (!variable) throw new Error(`Unsupported message parameter ${parameter}`);
+        return ` ${variable[1]}`;
+      });
+    return `{{message '${match[1]}'${parameters.join('')}}}`;
+  }
+  match = /^\(?@\{\|(.*)\|\}\)?$/.exec(value);
+  if (match) {
+    return match[1].replace(/\$\{([\w.]+)\}/g, (_, variable) => variables[variable] ?? `{{${variable}}}`);
+  }
+  throw new Error(`Unsupported Thymeleaf expression ${value}`);
+};
+
+/** The attributes of a tag with their th: attributes converted, and the converted th:text if any. */
+const convertAttributes = attributesText => {
+  const attributes = [...attributesText.matchAll(/([\w:-]+)="([^"]*)"/g)].map(([, name, value]) => ({ name, value }));
+  const variables = {};
+  for (const { value } of attributes.filter(attribute => attribute.name === 'th:with')) {
+    for (const definition of value.split(/,(?![^(]*\))/)) {
+      const [, variable, expression] = /^\s*(\w+)\s*=\s*(.*)$/.exec(definition) ?? [];
+      if (!variable) throw new Error(`Unsupported th:with ${value}`);
+      variables[variable] = toHandlebarsValue(expression, variables);
+    }
+  }
+  let text;
+  const kept = [];
+  for (const { name, value } of attributes) {
+    if (name === 'th:with' || name.startsWith('xmlns:th')) continue;
+    if (name === 'th:text') {
+      text = toHandlebarsValue(value, variables);
+    } else if (name.startsWith('th:')) {
+      kept.push({ name: name.substring(3), value: toHandlebarsValue(value, variables) });
+    } else if (!attributes.some(attribute => attribute.name === `th:${name}`)) {
+      kept.push({ name, value });
+    }
+  }
+  return { attributes: kept.map(({ name, value }) => ` ${name}="${value}"`).join(''), text };
+};
+
+/**
+ * Converts a mail template of JHipster Spring Boot (Thymeleaf) to a Handlebars template of the mail module, for the
+ * subset its account mails use: th:text on the elements without children, the other th: attributes (th:href, th:lang)
+ * and the th:with variables. The output only interpolates values, escaped, and calls the message helper: it runs no
+ * code. An expression or an attribute out of that subset fails the generation instead of giving a broken template.
+ */
+export const thymeleafMailToHandlebars = content => {
+  const result = content
+    // The leaf elements with a th:text, their content replaced by its value.
+    .replace(/<(\w+)((?:\s+[\w:-]+="[^"]*")*)\s*>[^<]*<\/\1>/g, (element, tag, attributesText) => {
+      if (!attributesText.includes('th:text=')) return element;
+      const { attributes, text } = convertAttributes(attributesText);
+      return `<${tag}${attributes}>${text}</${tag}>`;
+    })
+    // The other tags with th: attributes.
+    .replace(/<(\w+)((?:\s+[\w:-]+="[^"]*")*)\s*(\/?)>/g, (tag, name, attributesText, selfClosing) => {
+      if (!attributesText.includes('th:')) return tag;
+      const { attributes, text } = convertAttributes(attributesText);
+      if (text !== undefined) throw new Error(`Unsupported th:text on the element ${name} with children`);
+      return `<${name}${attributes}${selfClosing ? ' /' : ''}>`;
+    });
+  if (/\sth:|xmlns:th/.test(result)) throw new Error('Unsupported Thymeleaf attribute left in the mail template');
+  return result;
+};

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

@@ -0,0 +1,376 @@
+import { bigDecimalPrecision } from './columns.js';
+import { serverEnumInfo } from './enums.js';
+
+/**
+ * The migrations of the SQL databases, like the Liquibase changelogs of JHipster Spring Boot: the tables of the built-in
+ * users (CreateTables), then for each entity the migration adding its table and the one adding its constraints (its
+ * foreign keys and its join tables). The tables and the columns are the ones TypeORM maps the entities to, with their
+ * names, so a database created by a former version of the application (its schema synchronized from the entities) keeps
+ * its schema.
+ *
+ * TypeORM runs the migrations in the order of the timestamp of the last 13 digits of their class name: the sections of
+ * the master.xml of Liquibase are ranges of timestamps. The changelogs of the tables are the migrations of the tables at
+ * 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.
+ */
+
+/**
+ * The offset of the timestamps of the constraints migrations, after the ones of every table: the timestamp of the
+ * constraints of an entity is the one of its table plus 3000000000000 (4702121677000 for 1702121677000), so its name, like
+ * the constraints changelog of Liquibase named by the changelogDate of the entity, never changes, whatever the entities it
+ * references. The tables of the entities created up to 95 years after the first one stay before every constraints migration.
+ */
+export const CONSTRAINTS_TIMESTAMP_OFFSET = 3 * 10 ** 12;
+
+/**
+ * The offset of the timestamps of the migrations of the developers, created by the typeorm:migration scripts: their time
+ * plus 6000000000000, after the constraints migrations of every entity created before, like the changelogs added at the
+ * end of the master.xml of Liquibase; within 13 digits until 2096.
+ */
+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',
+  number: 'Number',
+  boolean: 'Boolean',
+  Date: 'Date',
+};
+
+/** A string literal of TypeScript. */
+const literal = value => `'${String(value).replaceAll('\\', '\\\\').replaceAll("'", "\\'")}'`;
+
+/** The migration column of the primary key of an entity, like its @PrimaryGeneratedColumn. */
+export const primaryKeyColumn = entity => ({
+  name: entity.primaryKey.name,
+  type: entity.primaryKey.typeUUID ? literal('uuid') : 'Number',
+  primary: true,
+  generated: entity.primaryKey.typeUUID ? 'uuid' : 'increment',
+});
+
+/** The migration column referencing the primary key of an entity: a join column, or a column of a join table. */
+const referenceColumn = (name, entity) => ({
+  name,
+  type: entity.primaryKey.typeUUID ? literal('uuid') : 'Number',
+});
+
+/** The migration columns of a field, like the @Column decorators of the entity: its column, and the content type of a blob. */
+export const fieldColumns = field => {
+  const { fieldValidationRequired: required, fieldValidationUnique: unique, fieldValidationMaxlength: maxlength } = field;
+  const nullable = !required;
+  const type = field.nodejsColumnType ? literal(field.nodejsColumnType) : (typeOfFieldType[field.nodejsFieldType] ?? 'String');
+  const column = { name: field.fieldNameAsDatabaseColumn, type, nullable, unique };
+  if (field.fieldIsEnum) {
+    // The values of the TypeScript enum of the field, the ones of the enum column of the databases having one (MySQL).
+    column.enum = `[${serverEnumInfo(field)
+      .enumValues.map(({ value }) => literal(value))
+      .join(', ')}]`;
+  } else if (field.fieldType === 'BigDecimal') {
+    Object.assign(column, bigDecimalPrecision);
+  } else if (!['Instant', 'ZonedDateTime', 'LocalDate'].includes(field.fieldType) && maxlength) {
+    column.length = field.fieldValidateRulesMaxlength;
+  }
+  const columns = [column];
+  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).
+ */
+export const typeormCamelCase = text =>
+  text.replaceAll(/^([A-Z])|[\s\-_](\w)/g, (_match, first, next) => (next ? next.toUpperCase() : first.toLowerCase()));
+
+/** The join column of a relationship, named like TypeORM names it (the relationship and the primary key of the other entity). */
+const joinColumnName = relationship =>
+  typeormCamelCase(`${relationship.relationshipFieldName}_${relationship.otherEntity.primaryKey.name}`);
+
+/**
+ * The relationships of an entity with a join column, the persistableRelationships of JHipster but the many-to-many ones:
+ * the many-to-one ones, and the one-to-one ones on their owner side.
+ */
+const joinColumnRelationships = entity => entity.persistableRelationships.filter(relationship => !relationship.relationshipManyToMany);
+
+/**
+ * The names of the columns of a join table, like TypeORM names the ones of a @JoinTable: the same names, like the ones of a
+ * many-to-many relationship of an entity with itself named like its table, suffixed by _1 and _2.
+ */
+const junctionColumnNames = (joinColumnName, inverseJoinColumnName) =>
+  joinColumnName === inverseJoinColumnName
+    ? [`${joinColumnName}_1`, `${inverseJoinColumnName}_2`]
+    : [joinColumnName, inverseJoinColumnName];
+
+/** The relationships of an entity with a join table, the many-to-many ones on their owner side (shouldWriteJoinTable of JHipster). */
+const joinTableRelationships = entity => entity.relationships.filter(relationship => relationship.shouldWriteJoinTable);
+
+/**
+ * The join table of a many-to-many relationship on its owner side, the one of its @JoinTable and of its constraints
+ * migration: the joinTable of JHipster, its columns named by the table of the entity and the relationship.
+ */
+export const joinTable = (entity, relationship) => {
+  const [joinColumnName, inverseJoinColumnName] = junctionColumnNames(`${entity.entityTableName}_id`, `${relationship.columnName}_id`);
+  return {
+    name: relationship.joinTable.name,
+    joinColumn: {
+      ...referenceColumn(joinColumnName, entity),
+      referencedTableName: entity.entityTableName,
+      referencedColumnName: entity.primaryKey.name,
+    },
+    inverseJoinColumn: {
+      ...referenceColumn(inverseJoinColumnName, relationship.otherEntity),
+      referencedTableName: relationship.otherEntity.entityTableName,
+      referencedColumnName: relationship.otherEntity.primaryKey.name,
+    },
+  };
+};
+
+/** 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 {
+    ...migrationName('AddedEntity', entity.entityClass, timestamp),
+    tableName: entity.entityTableName,
+    columns: [
+      primaryKeyColumn(entity),
+      ...entity.fields.filter(field => !field.id).flatMap(fieldColumns),
+      ...relationships.map(relationship => ({
+        ...referenceColumn(joinColumnName(relationship), relationship.otherEntity),
+        nullable: true,
+      })),
+    ],
+    relationUniques: relationships
+      .filter(relationship => relationship.relationshipOneToOne)
+      .map(relationship => joinColumnName(relationship)),
+  };
+};
+
+/**
+ * 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, timestamp = entityTimestamp(entity)) => {
+  const joinColumns = joinColumnRelationships(entity);
+  const joinTables = joinTableRelationships(entity);
+  if (joinColumns.length === 0 && joinTables.length === 0) return undefined;
+  return {
+    ...migrationName('AddedEntityConstraints', entity.entityClass, timestamp + CONSTRAINTS_TIMESTAMP_OFFSET),
+    tableName: entity.entityTableName,
+    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.
+ */
+export const userAuthorityJoinTable = ({ user, authority }) => ({
+  name: `${user.entityTableName}_authorities_${authority.entityTableName}`,
+  joinColumn: {
+    ...referenceColumn(typeormCamelCase(`${user.entityTableName}_${user.primaryKey.name}`), user),
+    referencedTableName: user.entityTableName,
+    referencedColumnName: user.primaryKey.name,
+  },
+  inverseJoinColumn: {
+    name: typeormCamelCase(`${authority.entityTableName}_name`),
+    type: 'String',
+    referencedTableName: authority.entityTableName,
+    referencedColumnName: 'name',
+  },
+});

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

@@ -0,0 +1,25 @@
+/** An ISO-8601 duration, like Duration.parse of Java: the pattern of parseDuration (src/common/database/column-transformers.ts). */
+const ISO_DURATION = String.raw`/^([-+]?)P(?:([-+]?\d+)D)?(?:T(?:([-+]?\d+)H)?(?:([-+]?\d+)M)?(?:([-+]?)(\d+)(?:[.,](\d{0,9}))?S)?)?$/i`;
+
+/**
+ * The class-validator decorators of the type of each field type, like the JSON deserialization of JHipster Spring Boot refuses
+ * a value of another type (400), instead of the error of the database or of a column transformer (500): a number, a
+ * boolean, a UUID, an ISO-8601 instant, a yyyy-MM-dd date, a HH:mm:ss time or an ISO-8601 duration.
+ */
+const typeValidators = {
+  Integer: ['@IsInt()'],
+  Long: ['@IsInt()'],
+  Float: ['@IsNumber()'],
+  Double: ['@IsNumber()'],
+  BigDecimal: ['@IsNumber()'],
+  Boolean: ['@IsBoolean()'],
+  UUID: ['@IsUUID()'],
+  Instant: ['@IsISO8601()'],
+  ZonedDateTime: ['@IsISO8601()'],
+  LocalDate: [String.raw`@Matches(/^\d{4}-\d{2}-\d{2}$/)`, '@IsISO8601({ strict: true })'],
+  LocalTime: [String.raw`@Matches(/^\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?$/)`],
+  Duration: [`@Matches(${ISO_DURATION})`],
+};
+
+/** The class-validator decorators of the type of a field: none for a text, a blob or an enum (@IsEnum). */
+export const fieldTypeValidators = field => (field.fieldIsEnum ? [] : (typeValidators[field.fieldType] ?? []));

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

@@ -0,0 +1,16 @@
+.git
+Dockerfile
+.dockerignore
+node_modules
+yarn.lock
+
+<%= nodeServerRootDir %>node_modules
+<%= nodeServerRootDir %>dist
+<%= nodeServerRootDir %>.env
+<%= nodeServerRootDir %>yarn.lock
+
+<%= clientRootDir %>node_modules
+<%= clientRootDir %>yarn.lock
+
+<%= temporaryDir %>
+target

package/generators/node-server/templates/.gitignore.jhi.nodejs.ejs

@@ -0,0 +1,24 @@
+<%#
+ Copyright 2013-2023 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+<&_ if (!fragment.section) { -&>
+# Generated by jhipster-nodejs:node-server
+<%- nodeServerRootDir %>dist/
+# Local settings of the server, like secrets (the development profile is in .env.dev)
+<%- nodeServerRootDir %>.env
+<&_ } -&>