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

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

@@ -0,0 +1,318 @@
+import { afterEach, beforeEach, describe, expect, it, type MockInstance, vi } from 'vitest';
+import { Test, TestingModule } from '@nestjs/testing';
+import request from 'supertest';
+import { AppModule } from '../src/app.module.ts';
+import { configureApp } from '../src/app.config.ts';
+import { INestApplication } from '@nestjs/common';
+import { AuthGuard } from '../src/auth/guards/auth.guard.ts';
+import { RolesGuard } from '../src/auth/guards/roles.guard.ts';
+import { <%= user.dtoClass%> } from '../src/users/dto/user.dto.ts';
+import { UserService } from '../src/users/user.service.ts';
+import { MailService } from '../src/mail/mail.service.ts';
+import { comparePassword } from '../src/auth/password-util.ts';
+<%_ if (databaseTypeMongodb) { _%>
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { User } from '../src/users/user.entity.ts';
+<%_ } _%>
+
+describe('User', () => {
+    let app: INestApplication;
+    let service: UserService;
+    let sendCreationEmail: MockInstance<MailService['sendCreationEmail']>;
+<%_ if (databaseTypeMongodb) { _%>
+    let userRepository: Repository<User>;
+<%_ } _%>
+
+    const authGuardMock = { canActivate: (): any => true };
+    const rolesGuardMock = { canActivate: (): any => true };
+
+    const testUserRequestObject: any = {
+        login: 'userTestLogin',
+        firstName: 'UserTest',
+        lastName: 'UserTest',
+        email: 'usertest@localhost.it'
+    };
+
+    const testUserDTO: <%= user.dtoClass%> = {
+        login: 'userTestLogin',
+        firstName: 'UserTest',
+        lastName: 'UserTest',
+        email: 'usertest@localhost.it',
+        password: 'userTestLogin'
+    };
+
+<%_ if (databaseType !== 'mongodb') { _%>
+    // The user as the API gives it: without the keys the mails send.
+    const withoutKeys = ({ activationKey: _activationKey, resetKey: _resetKey, resetDate: _resetDate, ...user }: Partial<<%= user.dtoClass%>>): Partial<<%= user.dtoClass%>> => user;
+
+<%_ } _%>
+    beforeEach(async () => {
+        const moduleFixture: TestingModule = await Test.createTestingModule({
+            imports: [AppModule],
+        })
+            .overrideGuard(AuthGuard)
+            .useValue(authGuardMock)
+            .overrideGuard(RolesGuard)
+            .useValue(rolesGuardMock)
+            .compile();
+
+        app = moduleFixture.createNestApplication();
+        configureApp(app);
+        await app.init();
+        service = moduleFixture.get<UserService>(UserService);
+        // The mails are not sent, the tests check the users they are for.
+        sendCreationEmail = vi.spyOn(moduleFixture.get<MailService>(MailService), 'sendCreationEmail').mockResolvedValue();
+<%_ if (databaseTypeMongodb) { _%>
+        userRepository = moduleFixture.get<Repository<User>>(getRepositoryToken(User));
+<%_ } _%>
+    });
+
+    it('/POST create user', async () => {
+        const response = await request(app.getHttpServer())
+            .post('/api/admin/users')
+            .send(testUserRequestObject)
+            .expect(201);
+        const createdUser: <%= user.dtoClass%> = response.body;
+
+        // Like JHipster Spring Boot, the login in lower case, and the location of the user by its login.
+        expect(createdUser.login).toEqual(testUserRequestObject.login.toLowerCase());
+        expect(response.headers.location).toBe(`/api/admin/users/${encodeURIComponent(createdUser.login)}`);
+        // Like JHipster Spring Boot, an activated user with a random password, and a reset key sent by mail.
+        const savedUser = (await service.findByFields({ where: { login: createdUser.login } }))!;
+        expect(savedUser.activated).toBe(true);
+        expect(savedUser.resetKey).toBeTruthy();
+        expect(await comparePassword(testUserRequestObject.login, savedUser.password)).toBe(false);
+        expect(sendCreationEmail).toHaveBeenCalledWith(expect.objectContaining({ login: createdUser.login, resetKey: savedUser.resetKey }));
+        await service.delete(createdUser);
+    });
+
+    it('/POST create user with an id is a bad request, like JHipster Spring Boot', async () => {
+        const problem = (
+            await request(app.getHttpServer())
+                .post('/api/admin/users')
+                .send({ ...testUserRequestObject, id: <%- databaseTypeMongodb ? "'000000000000000000000042'" : '42' %> })
+                .expect(400)
+        ).body;
+
+        expect(problem).toMatchObject({ message: 'error.idexists', params: 'userManagement' });
+        expect(await service.findByFields({ where: { login: testUserRequestObject.login.toLowerCase() } })).toBeFalsy();
+    });
+
+    it('/POST create user keeps the fields of the user only: activated, its own keys and audit', async () => {
+        const createdUser: <%= user.dtoClass%> = (
+            await request(app.getHttpServer())
+                .post('/api/admin/users')
+                .send({ ...testUserRequestObject, activated: false, password: 'chosenPassword', activationKey: 'chosenKey', resetKey: 'chosenKey', createdBy: 'someone' })
+                .expect(201)
+        ).body;
+
+        const savedUser = (await service.findByFields({ where: { login: testUserRequestObject.login.toLowerCase() } }))!;
+        expect(savedUser.activated).toBe(true);
+        expect(savedUser.password).not.toEqual('chosenPassword');
+        expect(savedUser.activationKey).toBeFalsy();
+        expect(savedUser.resetKey).toEqual(expect.any(String));
+        expect(savedUser.resetKey).not.toEqual('chosenKey');
+        expect(savedUser.createdBy).not.toEqual('someone');
+        await service.delete(createdUser);
+    });
+
+    it('/POST create user with the login of another user is a login already used problem', async () => {
+        const savedUser = await service.save({ ...testUserDTO, login: 'usedlogin', email: 'usedlogin@localhost.it' });
+
+        const problem = (
+            await request(app.getHttpServer())
+                .post('/api/admin/users')
+                .send({ ...testUserRequestObject, login: 'UsedLogin' })
+                .expect(400)
+        ).body;
+
+        expect(problem).toMatchObject({ type: 'https://www.jhipster.tech/problem/login-already-used' });
+        await service.delete(savedUser);
+    });
+
+    it('removes the users not activated 3 days after their registration', async () => {
+        const registeredDate = new Date(Date.now() - 4 * 24 * 60 * 60 * 1000);
+        const notActivatedUser = await service.save({ ...testUserDTO, login: 'notactivated', email: 'notactivated@localhost.it', activated: false, activationKey: 'notActivatedKey', createdDate: registeredDate });
+        const recentUser = await service.save({ ...testUserDTO, login: 'recentuser', email: 'recentuser@localhost.it', activated: false, activationKey: 'recentKey' });
+
+<%_ if (databaseTypeMongodb) { _%>
+        // MongoDB gives the date of the creation whatever the saved user has.
+        await userRepository.update(notActivatedUser.id!, { createdDate: registeredDate });
+<%_ } _%>
+        await service.removeNotActivatedUsers();
+
+        expect(await service.findByFields({ where: { login: notActivatedUser.login } })).toBeFalsy();
+        expect(await service.findByFields({ where: { login: recentUser.login } })).toBeTruthy();
+        await service.delete(recentUser);
+    });
+
+    it('/GET public users gives the activated users by their id and login only, like JHipster Spring Boot', async () => {
+        const activated = await service.save({ ...testUserDTO, login: 'publicactive', email: 'publicactive@localhost.it', activated: true });
+        const inactive = await service.save({ ...testUserDTO, login: 'publicinactive', email: 'publicinactive@localhost.it', activated: false });
+
+        const users: Record<string, unknown>[] = (await request(app.getHttpServer()).get('/api/users?size=2000').expect(200)).body;
+
+        expect(users.find(user => user.login === 'publicactive')).toEqual({ id: expect.anything(), login: 'publicactive' });
+        expect(users.map(user => user.login)).not.toContain('publicinactive');
+        expect(users.every(user => Object.keys(user).sort().join() === 'id,login')).toBe(true);
+        await service.delete(activated);
+        await service.delete(inactive);
+    });
+
+    it('/GET public users sorted on a property out of the allowed ones is a bad request', () =>
+        request(app.getHttpServer()).get('/api/users?sort=password,asc').expect(400));
+
+    it('/POST create user with an invalid email is a validation error', async () => {
+        const response = await request(app.getHttpServer())
+            .post('/api/admin/users')
+            .send({ ...testUserRequestObject, email: 'not an email' })
+            .expect(400)
+            .expect('Content-Type', /application\/problem\+json/);
+
+        // The problem detail of JHipster Spring Boot, with the errors of the fields.
+        expect(response.body).toMatchObject({
+            type: 'https://www.jhipster.tech/problem/constraint-violation',
+            status: 400,
+            message: 'error.validation',
+            path: '/api/admin/users',
+            fieldErrors: [{ objectName: 'user', field: 'email', message: expect.any(String) }],
+        });
+    });
+
+    it('/GET all users', async () => {
+        const savedUser = await service.save({ ...testUserDTO, login: 'listeduser', email: 'listeduser@localhost.it' });
+        const response = await request(app.getHttpServer())
+            .get('/api/admin/users')
+            .expect(200);
+
+        expect(response.body.map((user: any) => user.login)).toContain(savedUser.login);
+        expect(Number(response.headers['x-total-count'])).toBeGreaterThanOrEqual(response.body.length);
+    });
+
+    it('/PUT update user', async () => {
+        testUserDTO.login = 'TestUserUpdate';
+        const { password: _savedPassword, lastModifiedDate: _savedLastModifiedDate, ...savedUser } = await service.save(testUserDTO);
+        savedUser.firstName = 'Updated Name';
+
+        const { password: _updatedPassword, lastModifiedDate: _updatedLastModifiedDate, ...updatedUser } = (
+            await request(app.getHttpServer())
+                .put('/api/admin/users')
+                .send(savedUser)
+                .expect(200)
+        ).body;
+
+        <%_ if (databaseType !== 'mongodb') { _%>
+        // Like JHipster Spring Boot, the login in lower case.
+        expect(updatedUser).toEqual(JSON.parse(JSON.stringify(withoutKeys({ ...savedUser, login: savedUser.login.toLowerCase() }))));
+        <%_ } else { _%>
+        expect(updatedUser.firstName).toEqual(savedUser.firstName);
+        <%_ } _%>
+
+        await service.delete(savedUser as <%= user.dtoClass%>);
+    });
+
+    it('/PUT update user with a login name', async () => {
+        testUserDTO.login = 'TestUserUpdateLogin';
+        const { password: _savedPassword, lastModifiedDate: _savedLastModifiedDate, ...savedUser } = await service.save(testUserDTO);
+        savedUser.firstName = 'Updated Name';
+
+        const { password: _updatedPassword, lastModifiedDate: _updatedLastModifiedDate, ...updatedUser } = (
+            await request(app.getHttpServer())
+                .put('/api/admin/users/' + savedUser.login)
+                .send(savedUser)
+                .expect(200)
+        ).body;
+
+        <%_ if (databaseType !== 'mongodb') { _%>
+        // Like JHipster Spring Boot, the login in lower case.
+        expect(updatedUser).toEqual(JSON.parse(JSON.stringify(withoutKeys({ ...savedUser, login: savedUser.login.toLowerCase() }))));
+        <%_ } else { _%>
+        expect(updatedUser.firstName).toEqual(savedUser.firstName);
+        <%_ } _%>
+
+        await service.delete(savedUser as <%= user.dtoClass%>);
+    });
+
+    it('/PUT update user keeps the password and the keys of the user', async () => {
+        testUserDTO.login = 'testuserkeep';
+        const savedUser = await service.save({ ...testUserDTO, resetKey: 'savedKey' });
+
+        await request(app.getHttpServer())
+            .put('/api/admin/users')
+            .send({ ...savedUser, firstName: 'Updated Name', password: 'chosenPassword', resetKey: 'chosenKey' })
+            .expect(200);
+
+        const updatedUser = (await service.findByFields({ where: { login: 'testuserkeep' } }))!;
+        expect(updatedUser.firstName).toEqual('Updated Name');
+        expect(updatedUser.password).toEqual(savedUser.password);
+        expect(updatedUser.resetKey).toEqual('savedKey');
+        await service.delete(updatedUser);
+    });
+
+    it('/PUT update an unknown user is not found, like JHipster Spring Boot', () =>
+        request(app.getHttpServer())
+            .put('/api/admin/users')
+            .send({ ...testUserRequestObject, login: 'unknownuser', email: 'unknownuser@localhost.it', id: <%- databaseTypeMongodb ? "'000000000000000000000042'" : '42' %> })
+            .expect(404));
+
+    it('/GET user with a login name gives its authorities', async () => {
+        testUserDTO.login = 'testusergetauthorities';
+        const savedUser = await service.save({ ...testUserDTO, authorities: ['ROLE_USER'] });
+
+        const getUser: <%= user.dtoClass%> = (await request(app.getHttpServer()).get('/api/admin/users/testusergetauthorities').expect(200)).body;
+
+        expect(getUser.authorities).toEqual(['ROLE_USER']);
+        await service.delete(savedUser);
+    });
+
+    it('/GET user with a login name', async () => {
+        testUserDTO.login = 'TestUserGet';
+        const savedUser: <%= user.dtoClass%> = await service.save(testUserDTO);
+        <%_ if (databaseType !== 'mongodb') { _%>
+        const { password: _password, ...savedUserWithoutPassword } = savedUser;
+        <%_ } _%>
+
+        const getUser: <%= user.dtoClass%> = (
+            await request(app.getHttpServer())
+                .get('/api/admin/users/' + savedUser.login)
+                .expect(200)
+        ).body;
+
+        <%_ if (databaseType !== 'mongodb') { _%>
+        expect(getUser).toEqual(JSON.parse(JSON.stringify({ ...withoutKeys(savedUserWithoutPassword), authorities: [] })));
+        <%_ } else { _%>
+        expect(getUser.login).toEqual(savedUser.login);
+        <%_ } _%>
+
+        await service.delete(savedUser);
+    });
+
+    it('/DELETE user', async () => {
+        testUserDTO.login = 'TestUserDelete';
+        const savedUser: <%= user.dtoClass%> = await service.save(testUserDTO);
+
+        await request(app.getHttpServer())
+            .delete('/api/admin/users/' + savedUser.login)
+            .expect(204);
+
+        const userUndefined = await service.findById(savedUser.id!);
+        expect(userUndefined).toBeUndefined();
+    });
+
+    it('/GET users sorted on a property of the user', async () => {
+        await request(app.getHttpServer()).get('/api/admin/users?sort=login,desc').expect(200);
+        await request(app.getHttpServer()).get('/api/admin/users?sort=createdDate,asc').expect(200);
+    });
+
+    it('/GET users sorted on the password or a key of the user', async () => {
+        for (const property of ['password', 'activationKey', 'resetKey']) {
+            const response = await request(app.getHttpServer()).get(`/api/admin/users?sort=${property},asc`).expect(400);
+            expect(response.body.detail).toBe(`Invalid sort property: ${property}`);
+        }
+    });
+
+    afterEach(async () => {
+        await app?.close();
+    });
+});

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

@@ -0,0 +1 @@
+BACKEND_ENV=dev

package/generators/node-server/templates/server/eslint.config.mjs.ejs

@@ -0,0 +1,48 @@
+import eslint from '@eslint/js';
+import globals from 'globals';
+import prettier from 'eslint-plugin-prettier/recommended';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  {
+    linterOptions: {
+      reportUnusedDisableDirectives: 'error',
+    },
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+    },
+  },
+  { ignores: ['dist', 'coverage'] },
+  eslint.configs.recommended,
+  {
+    files: ['**/*.{js,cjs,mjs}'],
+    rules: {
+      'no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
+    },
+  },
+  {
+    files: ['**/*.ts'],
+    extends: [...tseslint.configs.recommendedTypeChecked],
+    languageOptions: {
+      parserOptions: {
+        'project': ['./tsconfig.json'],
+      },
+    },
+    rules: {
+      'no-prototype-builtins': 'off',
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/no-floating-promises': 'off',
+      '@typescript-eslint/no-redundant-type-constituents': 'off',
+      '@typescript-eslint/no-require-imports': 'off',
+      '@typescript-eslint/no-unsafe-argument': 'off',
+      '@typescript-eslint/no-unsafe-assignment': 'off',
+      '@typescript-eslint/no-unsafe-call': 'off',
+      '@typescript-eslint/no-unsafe-member-access': 'off',
+      '@typescript-eslint/no-unsafe-return': 'off',
+      '@typescript-eslint/no-unused-vars': ['error', { 'argsIgnorePattern': '^_', 'varsIgnorePattern': '^_' }],
+    },
+  },
+  prettier,
+);

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

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://json.schemastore.org/nest-cli",
+  "language": "ts",
+  "collection": "@nestjs/schematics",
+  "sourceRoot": "src",
+  "compilerOptions": {
+    "deleteOutDir": true,
+    "assets": [{ "include": "config/**/*", "outDir": "dist" }<% if (generateUserManagement) { %>, { "include": "i18n/**/*", "outDir": "dist" }, { "include": "templates/**/*", "outDir": "dist" }<% } %>],
+    "watchAssets": true
+  }
+}

package/generators/node-server/templates/server/ormconfig.ts.ejs

@@ -0,0 +1,35 @@
+// DataSource of the typeorm CLI (the typeorm npm scripts): the database of the application, of the profiles BACKEND_ENV
+// activates. Node.js runs this file as it is (type stripping) and imports the build in dist: the entities and the
+// migrations of src have decorators, which Node.js does not run.
+import { config as loadEnv } from 'dotenv';
+import { DataSource, type DataSourceOptions } from 'typeorm';
+import type * as OrmConfigModule from './src/orm.config.ts';
+<%_ if (databaseTypeMongodb) { _%>
+import type * as ConfigModule from './src/config.ts';
+<%_ } _%>
+
+// The local settings of .env, then the development profile of .env.dev, like the development scripts: a variable set in
+// the environment wins, like BACKEND_ENV=prod.
+loadEnv({ path: ['.env', '.env.dev'], quiet: true });
+
+const build = './dist';
+const { ormConfig } = (await import(`${build}/orm.config.js`)) as typeof OrmConfigModule;
+<%_ if (databaseTypeMongodb) { _%>
+const { activeProfiles, config } = (await import(`${build}/config.js`)) as typeof ConfigModule;
+
+// An embedded database (the in-memory MongoDB server of the test profile) is a new and empty database for each command.
+if (config.get('database.embedded')) {
+  throw new Error(`The typeorm scripts need a MongoDB database, not the embedded one of the ${activeProfiles.join(',')} profiles.`);
+}
+<%_ } _%>
+
+export default new DataSource({
+  ...<%- databaseTypeMongodb ? '(await ormConfig())' : 'ormConfig()' %>,
+  // Every entity, the built-in ones loaded by autoLoadEntities in the application included.
+  entities: [`${import.meta.dirname}/dist/**/*.entity.js`],
+  // Every migration, the ones created or generated by the scripts included.
+  migrations: [`${import.meta.dirname}/dist/migrations/*.js`],
+  // The CLI changes the schema only when a command asks it.
+  synchronize: false,
+  migrationsRun: false,
+} as DataSourceOptions);

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

@@ -0,0 +1,143 @@
+{
+  "name": "<%= dasherizedBaseName %>-server",
+  "version": "0.0.1",
+  "description": "",
+  "author": "",
+  "license": "MIT",
+  "type": "module",
+  "scripts": {
+    "clean": "rimraf dist <%= relativeDir(nodeServerRootDir, temporaryDir) %>db/",
+    "build": "nest build",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "sonar:scanner": "sonar-scanner",
+    "start:dev": "nest start --watch --env-file .env.dev",
+    "start:debug": "nest start --debug --watch --env-file .env.dev",
+    "start:prod": "node dist/main.js",
+    "start": "npm run clean && nest start --watch --env-file .env.dev",
+    "lint": "eslint .",
+    "lint:fix": "npm run lint -- --fix",
+    "pretest": "npm run lint && npm run typecheck",
+    "test": "vitest run",
+    "test:cov": "vitest run --coverage",
+    "test:watch": "vitest",
+    "test:debug": "vitest --inspect-brk --no-file-parallelism",
+    "test:e2e": "vitest run --config ./vitest.config.e2e.ts --coverage --silent",
+    "typecheck": "tsc --noEmit",
+    "typeorm": "nest build && typeorm -d ormconfig.ts",
+<%_ if (databaseTypeSql) { _%>
+    "typeorm:migration:create": "node typeorm-migration.ts migration:create src/migrations/migration",
+    "typeorm:migration:generate": "nest build && node typeorm-migration.ts migration:generate src/migrations/schema -d ormconfig.ts",
+<%_ } else { _%>
+    "typeorm:migration:create": "typeorm migration:create src/migrations/migration",
+<%_ } _%>
+    "typeorm:migration:run": "npm run typeorm -- migration:run",
+    "typeorm:migration:revert": "npm run typeorm -- migration:revert",
+    "typeorm:migration:show": "npm run typeorm -- migration:show"<% if (databaseTypeSql) { %>,<% } %>
+<%_ if (databaseTypeSql) { _%>
+    "typeorm:schema:log": "npm run typeorm -- schema:log",
+    "typeorm:schema:sync": "npm run typeorm -- schema:sync"
+<%_ } _%>
+  },
+  "dependencies": {
+<%_ if (generateUserManagement) { _%>
+    "@nestjs-modules/mailer": "<%- nodeServerDependencies['@nestjs-modules/mailer'] %>",
+<%_ } _%>
+    "<%- nodeProdDatabaseDriver %>": "<%- nodeServerDependencies[nodeProdDatabaseDriver] %>",
+<%_ if (authenticationType === 'oauth2') { _%>
+    "@nestjs/axios": "<%- nodeServerDependencies['@nestjs/axios'] %>",
+<%_ } _%>
+<%_ if (authenticationUsesCsrf) { _%>
+    "express-session": "<%- nodeServerDependencies['express-session'] %>",
+<%_ } _%>
+    "@nestjs/common": "<%- nodeServerDependencies['@nestjs/common'] %>",
+    "@nestjs/config": "<%- nodeServerDependencies['@nestjs/config'] %>",
+    "@nestjs/core": "<%- nodeServerDependencies['@nestjs/core'] %>",
+<%_ if (authenticationType === 'jwt') { _%>
+    "@nestjs/jwt": "<%- nodeServerDependencies['@nestjs/jwt'] %>",
+<%_ } _%>
+    "@nestjs/passport": "<%- nodeServerDependencies['@nestjs/passport'] %>",
+    "@nestjs/platform-express": "<%- nodeServerDependencies['@nestjs/platform-express'] %>",
+    "express": "<%- nodeServerDependencies['express'] %>",
+<%_ if (generateUserManagement) { _%>
+    "@nestjs/schedule": "<%- nodeServerDependencies['@nestjs/schedule'] %>",
+<%_ } _%>
+<%_ if (!skipClient) { _%>
+    "@nestjs/serve-static": "<%- nodeServerDependencies['@nestjs/serve-static'] %>",
+<%_ } _%>
+    "@nestjs/swagger": "<%- nodeServerDependencies['@nestjs/swagger'] %>",
+    "@nestjs/terminus": "<%- nodeServerDependencies['@nestjs/terminus'] %>",
+    "@nestjs/typeorm": "<%- nodeServerDependencies['@nestjs/typeorm'] %>",
+<%_ if (authenticationType === 'jwt' || generateUserManagement) { _%>
+    "bcrypt": "<%- nodeServerDependencies['bcrypt'] %>",
+<%_ } _%>
+    "class-transformer": "<%- nodeServerDependencies['class-transformer'] %>",
+    "class-validator": "<%- nodeServerDependencies['class-validator'] %>",
+<%_ if (serviceDiscoveryEureka) { _%>
+    "cloud-config-client": "<%- nodeServerDependencies['cloud-config-client'] %>",
+<%_ } _%>
+<%_ if (serviceDiscoveryConsul) { _%>
+    "consul": "<%- nodeServerDependencies['consul'] %>",
+<%_ } _%>
+    "dotenv": "<%- nodeServerDependencies['dotenv'] %>",
+<%_ if (serviceDiscoveryEureka) { _%>
+    "@rocketsoftware/eureka-js-client": "<%- nodeServerDependencies['@rocketsoftware/eureka-js-client'] %>",
+<%_ } _%>
+<%_ if (generateUserManagement) { _%>
+    "handlebars": "<%- nodeServerDependencies['handlebars'] %>",
+<%_ } _%>
+    "js-yaml": "<%- nodeServerDependencies['js-yaml'] %>",
+<%_ if (authenticationType === 'oauth2') { _%>
+    "jwks-rsa": "<%- nodeServerDependencies['jwks-rsa'] %>",
+    "jwt-decode": "<%- nodeServerDependencies['jwt-decode'] %>",
+<%_ } _%>
+    "passport": "<%- nodeServerDependencies['passport'] %>",
+    "passport-jwt": "<%- nodeServerDependencies['passport-jwt'] %>",
+<%_ if (authenticationType === 'oauth2') {_%>
+    "passport-oauth2": "<%- nodeServerDependencies['passport-oauth2'] %>",
+<%_ } _%>
+    "prom-client": "<%- nodeServerDependencies['prom-client'] %>",
+    "qs": "<%- nodeServerDependencies['qs'] %>",
+    "reflect-metadata": "<%- nodeServerDependencies['reflect-metadata'] %>",
+    "rxjs": "<%- nodeServerDependencies['rxjs'] %>",
+    "swagger-ui-express": "<%- nodeServerDependencies['swagger-ui-express'] %>",
+    "typeorm": "<%- nodeServerDependencies['typeorm'] %>"
+  },
+  "devDependencies": {
+    "@nestjs/cli": "<%- nodeServerDependencies['@nestjs/cli'] %>",
+    "@nestjs/schematics": "<%- nodeServerDependencies['@nestjs/schematics'] %>",
+    "@nestjs/testing": "<%- nodeServerDependencies['@nestjs/testing'] %>",
+    "@types/bcrypt": "<%- nodeServerDependencies['@types/bcrypt'] %>",
+    "@types/express": "<%- nodeServerDependencies['@types/express'] %>",
+    "@types/express-serve-static-core": "<%- nodeServerDependencies['@types/express-serve-static-core'] %>",
+    "@types/superagent": "<%- nodeServerDependencies['@types/superagent'] %>",
+<%_ if (authenticationUsesCsrf) { _%>
+    "@types/express-session": "<%- nodeServerDependencies['@types/express-session'] %>",
+<%_ } _%>
+    "@types/node": "<%- nodeServerDependencies['@types/node'] %>",
+<%_ if (authenticationType === 'oauth2') { _%>
+    "@types/passport": "<%- nodeServerDependencies['@types/passport'] %>",
+<%_ } _%>
+    "@types/passport-jwt": "<%- nodeServerDependencies['@types/passport-jwt'] %>",
+<%_ if (authenticationType === 'oauth2') { _%>
+    "@types/passport-oauth2": "<%- nodeServerDependencies['@types/passport-oauth2'] %>",
+<%_ } _%>
+    "@types/qs": "<%- nodeServerDependencies['@types/qs'] %>",
+    "@types/supertest": "<%- nodeServerDependencies['@types/supertest'] %>",
+    "@vitest/coverage-v8": "<%- nodeServerDependencies['@vitest/coverage-v8'] %>",
+<%_ if (databaseType !== 'mongodb') { _%>
+    "<%- nodeDevDatabaseDriver %>": "<%- nodeServerDependencies[nodeDevDatabaseDriver] %>",
+<%_ } _%>
+    "eslint": "<%- nodeServerDependencies['eslint'] %>",
+    "eslint-config-prettier": "<%- nodeServerDependencies['eslint-config-prettier'] %>",
+    "eslint-plugin-prettier": "<%- nodeServerDependencies['eslint-plugin-prettier'] %>",
+<%_ if (databaseType === 'mongodb') { _%>
+    "mongodb-memory-server": "<%- nodeServerDependencies['mongodb-memory-server'] %>",
+<%_ } _%>
+    "rimraf": "<%- nodeServerDependencies['rimraf'] %>",
+    "sonarqube-scanner": "<%- nodeServerDependencies['sonarqube-scanner'] %>",
+    "supertest": "<%- nodeServerDependencies['supertest'] %>",
+    "typescript": "<%- nodeServerDependencies['typescript'] %>",
+    "vite": "<%- nodeServerDependencies['vite'] %>",
+    "vitest": "<%- nodeServerDependencies['vitest'] %>"
+  }
+}

package/generators/node-server/templates/server/sonar-project.properties.ejs

@@ -0,0 +1,10 @@
+# --- properties for sonar ---
+sonar.projectKey=<%= baseName %>-nodejs
+sonar.projectVersion=0.0.1
+sonar.host.url=http://localhost:9001
+sonar.sources=src
+# The specs next to the code and the end-to-end tests of e2e are the tests, not sources.
+sonar.exclusions=src/**/*.spec.ts
+sonar.tests=src,e2e
+sonar.test.inclusions=**/*.spec.ts,**/*.e2e-spec.ts
+sonar.typescript.lcov.reportPaths=coverage/lcov.info

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

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+import { trustProxy } from './app.config.ts';
+
+describe('trustProxy', () => {
+  it('trusts no proxy by default, like the forward-headers-strategy none of Spring Boot', () => {
+    expect(trustProxy('none')).toBe(false);
+    expect(trustProxy(undefined)).toBe(false);
+  });
+
+  it('trusts the proxies of the local networks with native, like the internal proxies of the RemoteIpValve of Tomcat', () => {
+    expect(trustProxy('native')).toBe('loopback, linklocal, uniquelocal');
+  });
+});