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

package/generators/node-server/command.js

@@ -0,0 +1,96 @@
+import chalk from 'chalk';
+import { asCommand } from 'generator-jhipster';
+import { command as commonCommand } from 'generator-jhipster/generators/common';
+import { command as javaSimpleApplicationCommand } from 'generator-jhipster/generators/java-simple-application';
+import { command as serverCommand } from 'generator-jhipster/generators/server';
+import { command as springBootCommand } from 'generator-jhipster/generators/spring-boot';
+
+const { applicationType } = commonCommand.configs;
+
+/**
+ * The JDL definition of an option of JHipster's commands. The server command of the blueprint replaces the one of
+ * JHipster, which imports spring-boot: the JDL of the blueprint cli only knows the options of its own commands.
+ * Without a jdl definition (generator-jhipster 9.4.0, whose JDL knows every option), nothing is added.
+ */
+const jdlOf = config => (config?.jdl ? { jdl: config.jdl } : {});
+
+/**
+ * The options of the Java server of JHipster the NodeJS server uses, for the JDL only (no cli option, no prompt). The
+ * other ones (searchEngine, messageBroker, buildTool, ...) are unknown options of the JDL of the blueprint.
+ */
+const jdlOptions = Object.fromEntries(
+  Object.entries({
+    databaseType: serverCommand.configs.databaseType,
+    devDatabaseType: serverCommand.configs.devDatabaseType,
+    serviceDiscoveryType: springBootCommand.configs.serviceDiscoveryType,
+    syncUserWithIdp: springBootCommand.configs.syncUserWithIdp,
+    packageName: javaSimpleApplicationCommand.configs.packageName,
+  })
+    .filter(([, config]) => config?.jdl)
+    .map(([name, { description, jdl, choices, scope }]) => [name, { description, jdl, choices, scope }]),
+);
+if (jdlOptions.devDatabaseType) {
+  // SQLite, the embedded development database of the NodeJS server, on disk or in memory, instead of the H2 databases of
+  // JHipster Spring Boot.
+  jdlOptions.devDatabaseType.choices = [
+    ...jdlOptions.devDatabaseType.choices.filter(choice => !choice.startsWith('h2')),
+    'sqlite',
+    'sqliteMemory',
+  ];
+}
+
+export default asCommand({
+  configs: {
+    ...jdlOptions,
+    // The secret shared with JHipster's Spring Boot applications, given by the JDL or, like for them, by the hidden
+    // --jwt-secret-key option (the one of the samples of a gateway and its microservices).
+    jwtSecretKey: springBootCommand.configs.jwtSecretKey,
+    applicationType,
+    serverPort: {
+      ...jdlOf(commonCommand.configs.serverPort),
+      prompt: {
+        when: answers => answers.applicationType === 'gateway' || answers.applicationType === 'microservice',
+        type: 'input',
+        validate: input => (/^([0-9]*)$/.test(input) ? true : 'This is not a valid port number.'),
+        message:
+          'As you are running in a microservice architecture, on which port would like your server to run? It should be unique to avoid port conflicts.',
+        default: answers => (answers.applicationType === 'gateway' ? '8080' : '8081'),
+      },
+      scope: 'storage',
+    },
+    authenticationType: {
+      ...jdlOf(commonCommand.configs.authenticationType),
+      cli: {
+        type: String,
+      },
+      prompt: {
+        type: 'list',
+        message: `Which ${chalk.yellow('*type*')} of authentication would you like to use?`,
+      },
+      choices: [
+        { value: 'jwt', name: 'JWT authentication (stateless, with a token)' },
+        { value: 'oauth2', name: 'OAuth 2.0 / OIDC Authentication (stateful, works with Okta)' },
+      ],
+      scope: 'storage',
+    },
+    prodDatabaseType: {
+      ...jdlOf(serverCommand.configs.prodDatabaseType),
+      cli: {
+        type: String,
+      },
+      prompt: {
+        type: 'list',
+        message: `Which ${chalk.yellow('*production*')} database would you like to use?`,
+      },
+      choices: [
+        { value: 'postgresql', name: 'PostgreSQL' },
+        { value: 'mysql', name: 'MySQL' },
+        { value: 'mariadb', name: 'MariaDB' },
+        { value: 'oracle', name: 'Oracle (Please follow our documentation to use the Oracle proprietary driver)' },
+        { value: 'mssql', name: 'Microsoft SQL Server' },
+        { value: 'mongodb', name: 'MongoDB' },
+      ],
+      scope: 'storage',
+    },
+  },
+});

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

@@ -0,0 +1,41 @@
+import { SERVER_NODEJS_SRC_DIR } from '../generator-nodejs-constants.js';
+
+const SERVER_NODEJS_DIR = `${SERVER_NODEJS_SRC_DIR}/`;
+
+/**
+ * The default is to use a file path string. It implies use of the template method.
+ * For any other config an object { file:.., method:.., template:.. } can be used
+ */
+export const entityFiles = {
+  server: [
+    {
+      path: SERVER_NODEJS_DIR,
+      renameTo: (data, filepath) => `${SERVER_NODEJS_DIR}${filepath.replaceAll('_entityFileName_', data.entityFileName)}`,
+      templates: [
+        'src/entities/_entityFileName_/_entityFileName_.entity.ts',
+        'src/entities/_entityFileName_/_entityFileName_.module.ts',
+        'src/entities/_entityFileName_/_entityFileName_.service.ts',
+        'src/entities/_entityFileName_/dto/_entityFileName_.dto.ts',
+        'src/entities/_entityFileName_/_entityFileName_.mapper.ts',
+        'src/entities/_entityFileName_/_entityFileName_.controller.ts',
+        'e2e/_entityFileName_.e2e-spec.ts',
+        'e2e/_entityFileName_.database.e2e-spec.ts',
+      ],
+    },
+  ],
+  // 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/files.js

@@ -0,0 +1,254 @@
+import { SERVER_NODEJS_SRC_DIR } from '../generator-nodejs-constants.js';
+
+const SERVER_NODEJS_DIR = `${SERVER_NODEJS_SRC_DIR}/`;
+
+export const serverFiles = {
+  common: [
+    {
+      templates: ['.dockerignore', 'README.md.jhi.nodejs', '.gitignore.jhi.nodejs', 'Dockerfile'],
+    },
+    {
+      path: SERVER_NODEJS_DIR,
+      // The users administration API, not generated with OAuth2 (users come from the identity provider).
+      condition: ctx => ctx.generateUserManagement,
+      templates: [
+        'src/users/user.controller.ts',
+        'e2e/user.e2e-spec.ts',
+        'src/mail/mail.service.ts',
+        'src/mail/mail.module.ts',
+        'src/mail/mail.service.spec.ts',
+      ],
+    },
+
+    {
+      path: SERVER_NODEJS_DIR,
+      // The users of the application, synchronized from the identity provider with OAuth2 and syncUserWithIdp.
+      condition: ctx => ctx.generateBuiltInUserEntity,
+      templates: [
+        'src/users/user.entity.ts',
+        'src/users/user.mapper.ts',
+        'src/users/user.service.ts',
+        'src/users/user.module.ts',
+        'src/users/public.user.controller.ts',
+      ],
+    },
+    {
+      path: SERVER_NODEJS_DIR,
+      // The transformers of the columns whose values the SQL drivers do not give as the API exchanges them.
+      condition: ctx => ctx.databaseTypeSql,
+      templates: ['src/common/database/column-transformers.ts', 'src/common/database/column-transformers.spec.ts'],
+    },
+    {
+      path: SERVER_NODEJS_DIR,
+      // The tables of the built-in users (SQL), the schema synchronized from the entities (MongoDB, its indices).
+      condition: ctx => ctx.databaseTypeMongodb || ctx.generateBuiltInUserEntity || ctx.generateBuiltInAuthorityEntity,
+      templates: ['src/migrations/1570200270081-CreateTables.ts'],
+    },
+    {
+      path: SERVER_NODEJS_DIR,
+      condition: ctx => ctx.databaseTypeSql,
+      // The column types of the database of the active profiles, given to the entities and to the migrations.
+      templates: ['src/migrations/support/schema.ts', 'src/common/database/column-types.ts', 'src/common/database/column-types.spec.ts'],
+    },
+    {
+      path: SERVER_NODEJS_DIR,
+      condition: ctx => ctx.generateBuiltInAuthorityEntity,
+      templates: [
+        'src/users/authority.entity.ts',
+        'src/migrations/1570200490072-SeedUsersRoles.ts',
+        'src/users/dto/authority.dto.ts',
+        'src/users/authority.controller.ts',
+        'e2e/authority.e2e-spec.ts',
+      ],
+    },
+    {
+      path: SERVER_NODEJS_DIR,
+      templates: [
+        'src/users/dto/user.dto.ts',
+        'src/auth/account.controller.ts',
+        'src/management/management.controller.ts',
+        'src/management/health.controller.ts',
+        'src/management/health.module.ts',
+        'src/management/management.module.ts',
+        'src/management/loggers.controller.ts',
+        'src/management/metrics.controller.ts',
+        'src/management/configuration.controller.ts',
+        'src/management/api-docs.controller.ts',
+        'src/management/api-docs.service.ts',
+        'src/common/metrics.ts',
+        'src/common/metrics.spec.ts',
+        'src/common/logging.ts',
+        'src/common/logging.spec.ts',
+        'src/auth/decorators/auth-user.decorator.ts',
+        'src/auth/auth.module.ts',
+        'src/config/application-dev.yml',
+        'src/config/application-test.yml',
+        'src/config.ts',
+        'src/config/application-prod.yml',
+        'src/config/application-secret-samples.yml',
+        'src/config/application-tls.yml',
+        'src/config/application-tls-samples.yml',
+        'src/config/application.yml',
+        'src/common/database/pagination.entity.ts',
+        'src/common/database/pagination.entity.spec.ts',
+        'src/common/database/base.entity.ts',
+        'src/auth/guards/roles.guard.ts',
+        'src/auth/guards/auth.guard.ts',
+        'src/auth/role-type.ts',
+        'src/auth/decorators/roles.decorator.ts',
+        'src/auth/index.ts',
+        'src/common/header-util.ts',
+        'src/common/interceptors/logging.interceptor.ts',
+        'src/common/request.ts',
+        'src/common/errors/error-constants.ts',
+        'src/common/errors/problem.exception.ts',
+        'src/common/errors/problem-details.filter.ts',
+        'src/auth/auth.service.ts',
+        'src/common/dto/base.dto.ts',
+        'src/main.ts',
+        'src/app.config.ts',
+        'src/application-config.ts',
+        'src/common/common.module.ts',
+        'src/swagger.ts',
+        'src/tls.ts',
+        'src/app.module.ts',
+        'src/orm.config.ts',
+        'tsconfig.build.json',
+        'src/management/management.controller.spec.ts',
+        'src/management/health.controller.spec.ts',
+        'src/common/interceptors/logging.interceptor.spec.ts',
+        'src/config.spec.ts',
+        'src/app.config.spec.ts',
+        'nest-cli.json',
+        {
+          // The profile of the development scripts (nest start --env-file .env.dev), not of the built application.
+          file: 'env',
+          renameTo: () => '.env.dev',
+        },
+        'eslint.config.mjs',
+        'package.json',
+        'tsconfig.json',
+        'vitest.config.ts',
+        'vitest.config.e2e.ts',
+        'README.md',
+        'sonar-project.properties',
+        'ormconfig.ts',
+      ],
+    },
+    {
+      path: SERVER_NODEJS_DIR,
+      // The migrations of the developers, created after the constraints migrations of the entities (SQL).
+      condition: ctx => ctx.databaseTypeSql,
+      templates: ['typeorm-migration.ts'],
+    },
+    {
+      path: SERVER_NODEJS_DIR,
+      condition: ctx => ctx.serviceDiscoveryEureka,
+      templates: ['src/registry/eureka.service.ts'],
+    },
+    {
+      path: SERVER_NODEJS_DIR,
+      condition: ctx => ctx.serviceDiscoveryConsul,
+      templates: ['src/registry/consul.service.ts'],
+    },
+    {
+      path: SERVER_NODEJS_DIR,
+      // Helper of the MongoDB updates: the MongoDB driver of TypeORM ignores the update: false option.
+      condition: ctx => ctx.databaseTypeMongodb,
+      templates: ['src/common/updatable-properties.ts'],
+    },
+    {
+      path: SERVER_NODEJS_DIR,
+      // Validates the sort of the entity lists by introspection of the TypeORM metadata.
+      templates: ['src/common/sortable-properties.ts'],
+    },
+  ],
+  e2e: [
+    {
+      path: SERVER_NODEJS_DIR,
+      templates: ['e2e/app.e2e-spec.ts', 'e2e/cors.e2e-spec.ts', 'e2e/management.e2e-spec.ts', 'e2e/setup.test.js'],
+    },
+    {
+      path: SERVER_NODEJS_DIR,
+      condition: generator => generator.generateUserManagement,
+      templates: ['e2e/account.e2e-spec.ts'],
+    },
+  ],
+  other: [
+    {
+      templates: ['package.json'],
+    },
+  ],
+  jwt: [
+    {
+      path: SERVER_NODEJS_DIR,
+      condition: ctx => ctx.authenticationTypeJwt,
+      templates: [
+        'src/auth/passport.jwt.strategy.ts',
+        'src/auth/payload.interface.ts',
+        'src/auth/jwt.config.ts',
+        'src/auth/jwt.config.spec.ts',
+      ],
+    },
+    {
+      path: SERVER_NODEJS_DIR,
+      // The authentication API, without built-in User (a microservice) the application only validates the tokens.
+      condition: ctx => ctx.authenticationTypeJwt && ctx.generateBuiltInUserEntity,
+      templates: ['src/auth/user.jwt.controller.ts', 'src/auth/dto/user-login.dto.ts'],
+    },
+  ],
+  userManagement: [
+    {
+      path: SERVER_NODEJS_DIR,
+      // The passwords of the users of the user management, the ones of JWT and of the sessions.
+      condition: ctx => ctx.generateUserManagement,
+      templates: [
+        'src/auth/password-util.ts',
+        'src/auth/password.service.ts',
+        'src/auth/dto/password-change.dto.ts',
+        'src/auth/dto/key-and-password.dto.ts',
+      ],
+    },
+  ],
+  session: [
+    {
+      path: SERVER_NODEJS_DIR,
+      // The sessions of the server, of the session login and of the OAuth2 login, protected from CSRF.
+      condition: ctx => ctx.authenticationUsesCsrf,
+      templates: [
+        'src/auth/csrf.middleware.ts',
+        'src/auth/csrf.middleware.spec.ts',
+        'src/auth/session.entity.ts',
+        'src/auth/session.store.ts',
+        'src/auth/session.store.spec.ts',
+      ],
+    },
+    {
+      path: SERVER_NODEJS_DIR,
+      condition: ctx => ctx.authenticationUsesCsrf && ctx.databaseTypeSql,
+      templates: ['src/migrations/1570200270082-CreateSessions.ts'],
+    },
+    {
+      path: SERVER_NODEJS_DIR,
+      condition: ctx => ctx.authenticationTypeSession,
+      templates: ['src/auth/user.session.controller.ts', 'src/auth/session-user.middleware.ts', 'e2e/session.e2e-spec.ts'],
+    },
+  ],
+  oauth2: [
+    {
+      path: SERVER_NODEJS_DIR,
+      condition: generator => generator.authenticationTypeOauth2,
+      templates: [
+        'src/auth/user.oauth2.controller.ts',
+        'src/auth/passport.oauth2.strategy.ts',
+        'src/auth/oauth2.config.ts',
+        'src/auth/oauth2.authorities.ts',
+        'src/auth/passport.oauth2-bearer.strategy.ts',
+        'src/auth/guards/oauth2-login.guard.ts',
+        'src/auth/oauth2.authorities.spec.ts',
+        'src/auth/passport.oauth2.strategy.spec.ts',
+        'e2e/oauth2-bearer.e2e-spec.ts',
+      ],
+    },
+  ],
+};