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

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,83 @@
+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) {
+          application.authority.skipClient = !application.clientFrameworkAngular;
+        }
+      },
+    });
+  }
+}

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/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.11",
+    "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.0",
+    "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);
+};

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;
+};