generator-jhipster 7.2.0 → 7.4.1

package/generators/client/templates/angular/src/main/webapp/app/shared/alert/alert-error.component.spec.ts.ejs

@@ -30,160 +30,158 @@ import { Alert, AlertService } from 'app/core/util/alert.service';
 
 import { AlertErrorComponent } from './alert-error.component';
 
-describe('Component Tests', () => {
-  describe('Alert Error Component', () => {
-    let comp: AlertErrorComponent;
-    let fixture: ComponentFixture<AlertErrorComponent>;
-    let eventManager: EventManager;
-    let alertService: AlertService;
-
-    beforeEach(
-      waitForAsync(() => {
-        TestBed.configureTestingModule({
+describe('Alert Error Component', () => {
+  let comp: AlertErrorComponent;
+  let fixture: ComponentFixture<AlertErrorComponent>;
+  let eventManager: EventManager;
+  let alertService: AlertService;
+
+  beforeEach(
+    waitForAsync(() => {
+      TestBed.configureTestingModule({
 <%_ if (enableTranslation) { _%>
-          imports: [TranslateModule.forRoot()],
+        imports: [TranslateModule.forRoot()],
 <%_ } _%>
-          declarations: [AlertErrorComponent],
-          providers: [EventManager, AlertService],
-        })
-          .overrideTemplate(AlertErrorComponent, '')
-          .compileComponents();
+        declarations: [AlertErrorComponent],
+        providers: [EventManager, AlertService],
       })
-    );
-
-    beforeEach(() => {
-      fixture = TestBed.createComponent(AlertErrorComponent);
-      comp = fixture.componentInstance;
-      eventManager = TestBed.inject(EventManager);
-      alertService = TestBed.inject(AlertService);
-      alertService.addAlert = (alert: Alert, alerts?: Alert[]) => {
-        if (alerts) {
-          alerts.push(alert);
-        }
-        return alert;
-      };
-    });
+        .overrideTemplate(AlertErrorComponent, '')
+        .compileComponents();
+    })
+  );
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(AlertErrorComponent);
+    comp = fixture.componentInstance;
+    eventManager = TestBed.inject(EventManager);
+    alertService = TestBed.inject(AlertService);
+    alertService.addAlert = (alert: Alert, alerts?: Alert[]) => {
+      if (alerts) {
+        alerts.push(alert);
+      }
+      return alert;
+    };
+  });
 
-    describe('Error Handling', () => {
-      it('Should display an alert on status 0', () => {
-        // GIVEN
-        eventManager.broadcast({ name: '<%= frontendAppName %>.httpError', content: { status: 0 } });
-        // THEN
-        expect(comp.alerts.length).toBe(1);
-        expect(comp.alerts[0].<%= mainAlertField %>).toBe(<% if (enableTranslation) { %>'error.server.not.reachable'<% } else { %>'Server not reachable'<% } %>);
-      });
+  describe('Error Handling', () => {
+    it('Should display an alert on status 0', () => {
+      // GIVEN
+      eventManager.broadcast({ name: '<%= frontendAppName %>.httpError', content: { status: 0 } });
+      // THEN
+      expect(comp.alerts.length).toBe(1);
+      expect(comp.alerts[0].<%= mainAlertField %>).toBe(<% if (enableTranslation) { %>'error.server.not.reachable'<% } else { %>'Server not reachable'<% } %>);
+    });
 
-      it('Should display an alert on status 404', () => {
-        // GIVEN
-        eventManager.broadcast({ name: '<%= frontendAppName %>.httpError', content: { status: 404 } });
-        // THEN
-        expect(comp.alerts.length).toBe(1);
-        expect(comp.alerts[0].<%= mainAlertField %>).toBe(<% if (enableTranslation) { %>'error.url.not.found'<% } else { %>'Not found'<% } %>);
-      });
+    it('Should display an alert on status 404', () => {
+      // GIVEN
+      eventManager.broadcast({ name: '<%= frontendAppName %>.httpError', content: { status: 404 } });
+      // THEN
+      expect(comp.alerts.length).toBe(1);
+      expect(comp.alerts[0].<%= mainAlertField %>).toBe(<% if (enableTranslation) { %>'error.url.not.found'<% } else { %>'Not found'<% } %>);
+    });
 
-      it('Should display an alert on generic error', () => {
-        // GIVEN
-        eventManager.broadcast({ name: '<%= frontendAppName %>.httpError', content: { error: { message: 'Error Message' } } });
-        eventManager.broadcast({ name: '<%= frontendAppName %>.httpError', content: { error: 'Second Error Message' } });
-        // THEN
-        expect(comp.alerts.length).toBe(2);
-        expect(comp.alerts[0].<%= mainAlertField %>).toBe('Error Message');
-        expect(comp.alerts[1].<%= mainAlertField %>).toBe('Second Error Message');
-      });
+    it('Should display an alert on generic error', () => {
+      // GIVEN
+      eventManager.broadcast({ name: '<%= frontendAppName %>.httpError', content: { error: { message: 'Error Message' } } });
+      eventManager.broadcast({ name: '<%= frontendAppName %>.httpError', content: { error: 'Second Error Message' } });
+      // THEN
+      expect(comp.alerts.length).toBe(2);
+      expect(comp.alerts[0].<%= mainAlertField %>).toBe('Error Message');
+      expect(comp.alerts[1].<%= mainAlertField %>).toBe('Second Error Message');
+    });
 
-      it('Should display an alert on status 400 for generic error', () => {
-        // GIVEN
-        const response = new HttpErrorResponse({
-          url: 'http://localhost:8080/api/foos',
-          headers: new HttpHeaders(),
+    it('Should display an alert on status 400 for generic error', () => {
+      // GIVEN
+      const response = new HttpErrorResponse({
+        url: 'http://localhost:8080/api/foos',
+        headers: new HttpHeaders(),
+        status: 400,
+        statusText: 'Bad Request',
+        error: {
+          type: 'https://www.jhipster.tech/problem/constraint-violation',
+          title: 'Bad Request',
           status: 400,
-          statusText: 'Bad Request',
-          error: {
-            type: 'https://www.jhipster.tech/problem/constraint-violation',
-            title: 'Bad Request',
-            status: 400,
-            path: '/api/foos',
-            message: 'error.validation',
-          },
-        });
-        eventManager.broadcast({ name: '<%= frontendAppName %>.httpError', content: response });
-        // THEN
-        expect(comp.alerts.length).toBe(1);
-        expect(comp.alerts[0].<%= mainAlertField %>).toBe('error.validation');
+          path: '/api/foos',
+          message: 'error.validation',
+        },
       });
+      eventManager.broadcast({ name: '<%= frontendAppName %>.httpError', content: response });
+      // THEN
+      expect(comp.alerts.length).toBe(1);
+      expect(comp.alerts[0].<%= mainAlertField %>).toBe('error.validation');
+    });
 
-      it('Should display an alert on status 400 for generic error without message', () => {
-        // GIVEN
-        const response = new HttpErrorResponse({
-          url: 'http://localhost:8080/api/foos',
-          headers: new HttpHeaders(),
-          status: 400,
-          error: 'Bad Request',
-        });
-        eventManager.broadcast({ name: '<%= frontendAppName %>.httpError', content: response });
-        // THEN
-        expect(comp.alerts.length).toBe(1);
-        expect(comp.alerts[0].<%= mainAlertField %>).toBe('Bad Request');
+    it('Should display an alert on status 400 for generic error without message', () => {
+      // GIVEN
+      const response = new HttpErrorResponse({
+        url: 'http://localhost:8080/api/foos',
+        headers: new HttpHeaders(),
+        status: 400,
+        error: 'Bad Request',
       });
+      eventManager.broadcast({ name: '<%= frontendAppName %>.httpError', content: response });
+      // THEN
+      expect(comp.alerts.length).toBe(1);
+      expect(comp.alerts[0].<%= mainAlertField %>).toBe('Bad Request');
+    });
 
-      it('Should display an alert on status 400 for invalid parameters', () => {
-        // GIVEN
-        const response = new HttpErrorResponse({
-          url: 'http://localhost:8080/api/foos',
-          headers: new HttpHeaders(),
+    it('Should display an alert on status 400 for invalid parameters', () => {
+      // GIVEN
+      const response = new HttpErrorResponse({
+        url: 'http://localhost:8080/api/foos',
+        headers: new HttpHeaders(),
+        status: 400,
+        statusText: 'Bad Request',
+        error: {
+          type: 'https://www.jhipster.tech/problem/constraint-violation',
+          title: 'Method argument not valid',
           status: 400,
-          statusText: 'Bad Request',
-          error: {
-            type: 'https://www.jhipster.tech/problem/constraint-violation',
-            title: 'Method argument not valid',
-            status: 400,
-            path: '/api/foos',
-            message: 'error.validation',
-            fieldErrors: [{ objectName: 'foo', field: 'minField', message: 'Min' }],
-          },
-        });
-        eventManager.broadcast({ name: '<%= frontendAppName %>.httpError', content: response });
-        // THEN
-        expect(comp.alerts.length).toBe(1);
-        expect(comp.alerts[0].<%= mainAlertField %>).toBe(<% if (enableTranslation) { %>'error.Size'<% } else { %>'Error on field "MinField"'<% } %>);
+          path: '/api/foos',
+          message: 'error.validation',
+          fieldErrors: [{ objectName: 'foo', field: 'minField', message: 'Min' }],
+        },
       });
+      eventManager.broadcast({ name: '<%= frontendAppName %>.httpError', content: response });
+      // THEN
+      expect(comp.alerts.length).toBe(1);
+      expect(comp.alerts[0].<%= mainAlertField %>).toBe(<% if (enableTranslation) { %>'error.Size'<% } else { %>'Error on field "MinField"'<% } %>);
+    });
 
-      it('Should display an alert on status 400 for error headers', () => {
-        // GIVEN
-        const response = new HttpErrorResponse({
-          url: 'http://localhost:8080/api/foos',
-          headers: new HttpHeaders().append('app-error', 'Error Message').append('app-params', 'foo'),
+    it('Should display an alert on status 400 for error headers', () => {
+      // GIVEN
+      const response = new HttpErrorResponse({
+        url: 'http://localhost:8080/api/foos',
+        headers: new HttpHeaders().append('app-error', 'Error Message').append('app-params', 'foo'),
+        status: 400,
+        statusText: 'Bad Request',
+        error: {
           status: 400,
-          statusText: 'Bad Request',
-          error: {
-            status: 400,
-            message: 'error.validation',
-          },
-        });
-        eventManager.broadcast({ name: '<%= frontendAppName %>.httpError', content: response });
-        // THEN
-        expect(comp.alerts.length).toBe(1);
-        expect(comp.alerts[0].<%= mainAlertField %>).toBe('Error Message');
+          message: 'error.validation',
+        },
       });
+      eventManager.broadcast({ name: '<%= frontendAppName %>.httpError', content: response });
+      // THEN
+      expect(comp.alerts.length).toBe(1);
+      expect(comp.alerts[0].<%= mainAlertField %>).toBe('Error Message');
+    });
 
-      it('Should display an alert on status 500 with detail', () => {
-        // GIVEN
-        const response = new HttpErrorResponse({
-          url: 'http://localhost:8080/api/foos',
-          headers: new HttpHeaders(),
+    it('Should display an alert on status 500 with detail', () => {
+      // GIVEN
+      const response = new HttpErrorResponse({
+        url: 'http://localhost:8080/api/foos',
+        headers: new HttpHeaders(),
+        status: 500,
+        statusText: 'Internal server error',
+        error: {
           status: 500,
-          statusText: 'Internal server error',
-          error: {
-            status: 500,
-            message: 'error.http.500',
-            detail: 'Detailed error message',
-          },
-        });
-        eventManager.broadcast({ name: '<%= frontendAppName %>.httpError', content: response });
-        // THEN
-        expect(comp.alerts.length).toBe(1);
-        expect(comp.alerts[0].<%= mainAlertField %>).toBe(<% if (enableTranslation) { %>'error.http.500'<% } else { %>'Detailed error message'<% } %>);
+          message: 'error.http.500',
+          detail: 'Detailed error message',
+        },
       });
+      eventManager.broadcast({ name: '<%= frontendAppName %>.httpError', content: response });
+      // THEN
+      expect(comp.alerts.length).toBe(1);
+      expect(comp.alerts[0].<%= mainAlertField %>).toBe(<% if (enableTranslation) { %>'error.http.500'<% } else { %>'Detailed error message'<% } %>);
     });
   });
 });

package/generators/client/templates/angular/src/main/webapp/app/shared/alert/alert.component.spec.ts.ejs

@@ -24,43 +24,41 @@ import { AlertService } from 'app/core/util/alert.service';
 
 import { AlertComponent } from './alert.component';
 
-describe('Component Tests', () => {
-  describe('Alert Component', () => {
-    let comp: AlertComponent;
-    let fixture: ComponentFixture<AlertComponent>;
-    let mockAlertService: AlertService;
+describe('Alert Component', () => {
+  let comp: AlertComponent;
+  let fixture: ComponentFixture<AlertComponent>;
+  let mockAlertService: AlertService;
 
-    beforeEach(
-      waitForAsync(() => {
-        TestBed.configureTestingModule({
-          declarations: [AlertComponent],
-          providers: [AlertService],
-        })
-          .overrideTemplate(AlertComponent, '')
-          .compileComponents();
+  beforeEach(
+    waitForAsync(() => {
+      TestBed.configureTestingModule({
+        declarations: [AlertComponent],
+        providers: [AlertService],
       })
-    );
+        .overrideTemplate(AlertComponent, '')
+        .compileComponents();
+    })
+  );
 
-    beforeEach(() => {
-      fixture = TestBed.createComponent(AlertComponent);
-      comp = fixture.componentInstance;
-      mockAlertService = TestBed.inject(AlertService);
-    });
+  beforeEach(() => {
+    fixture = TestBed.createComponent(AlertComponent);
+    comp = fixture.componentInstance;
+    mockAlertService = TestBed.inject(AlertService);
+  });
 
-    it('Should call alertService.get on init', () => {
-      // WHEN
-      comp.ngOnInit();
+  it('Should call alertService.get on init', () => {
+    // WHEN
+    comp.ngOnInit();
 
-      // THEN
-      expect(mockAlertService.get).toHaveBeenCalled();
-    });
+    // THEN
+    expect(mockAlertService.get).toHaveBeenCalled();
+  });
 
-    it('Should call alertService.clear on destroy', () => {
-      // WHEN
-      comp.ngOnDestroy();
+  it('Should call alertService.clear on destroy', () => {
+    // WHEN
+    comp.ngOnDestroy();
 
-      // THEN
-      expect(mockAlertService.clear).toHaveBeenCalled();
-    });
+    // THEN
+    expect(mockAlertService.clear).toHaveBeenCalled();
   });
 });

package/generators/client/templates/angular/webpack/webpack.custom.js.ejs

@@ -76,7 +76,7 @@ module.exports = async (config, options, targetOptions) => {
   if (config.devServer) {
     config.devServer.proxy = proxyConfig({ tls });
   }
-<%_ if (!this.applicationTypeMicroservice) { _%>
+
   if (targetOptions.target === 'serve' || config.watch) {
     config.plugins.push(
       new BrowserSyncPlugin(
@@ -85,7 +85,7 @@ module.exports = async (config, options, targetOptions) => {
           port: 9000,
           https: tls,
           proxy: {
-            target: `http${tls ? 's' : ''}://localhost:${targetOptions.target === 'serve' ? '<%= devServerPort %>' : '<%= serverPort %>'}`,
+            target: `http${tls ? 's' : ''}://localhost:${targetOptions.target === 'serve' ? '<%= devServerPort %>' : '<%= this.applicationTypeMicroservice ? gatewayServerPort : serverPort %>'}`,
             <%_ if (websocket === 'spring-websocket') { _%>
             ws: true,
             <%_ } _%>
@@ -113,7 +113,6 @@ module.exports = async (config, options, targetOptions) => {
       )
     );
   }
-<%_ } _%>
 
   if (config.mode === 'production') {
     config.plugins.push(

package/generators/client/templates/common/README.md.jhi.client.ejs

@@ -149,6 +149,40 @@ Note: There are still a few other things remaining to do for Leaflet that we won
 
 For further instructions on how to develop with JHipster, have a look at [Using JHipster in development][].
 
+<%_ if (microfrontend) { -%>
+### Developing Microfrontend
+
+Microservices doesn't contain every required backend feature to allow microfrontends to run alone.
+You must start a pre-built gateway version or from source.
+
+Start gateway from source:
+
+```
+cd gateway
+npm run docker:db:up # start database if necessary
+npm run docker:others:up # start service discovery and authentication service if necessary
+npm run app:start # alias for ./(mvnw|gradlew)
+```
+
+Microfrontend's `build-watch` script is configured to watch and compile microfrontend's sources and synchronizes with gateway's frontend.
+Start it using:
+
+```
+cd microfrontend
+npm run docker:db:up # start database if necessary
+npm run build-watch
+```
+
+It's possible to run microfrontend's frontend standalone using:
+
+```
+cd microfrontend
+npm run docker:db:up # start database if necessary
+npm watch # alias for `npm start` and `npm run backend:start` in parallel
+```
+
+<%_ } -%>
+
 <&_ } -&>
 <&_ if (fragment.testingSection) { -&>
 ### Client tests

package/generators/client/templates/common/package.json

@@ -1,12 +1,12 @@
 {
   "devDependencies": {
-    "@cypress/code-coverage": "3.9.11",
-    "babel-loader": "8.2.2",
-    "babel-plugin-istanbul": "6.0.0",
-    "cypress": "8.3.1",
-    "eslint-plugin-cypress": "2.11.3",
-    "cypress-audit": "1.0.0",
-    "lighthouse": "8.4.0",
+    "@cypress/code-coverage": "3.9.12",
+    "babel-loader": "8.2.3",
+    "babel-plugin-istanbul": "6.1.1",
+    "cypress": "9.0.0",
+    "eslint-plugin-cypress": "2.12.1",
+    "cypress-audit": "1.1.0",
+    "lighthouse": "9.1.0",
     "nyc": "15.1.0"
   },
   "dependencies": {

package/generators/client/templates/common/webpack/webpack.microfrontend.js.jhi.ejs

@@ -0,0 +1,56 @@
+<%#
+ Copyright 2013-2021 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.
+-%>
+<&_
+ // Register sections and max allowed fragments, 0 for unlimited.
+ fragments.registerSections({
+   importsSection:0,
+   moduleFederationSection: 0,
+   pluginsSection: 0,
+ });
+_&>
+
+const ModuleFederationPlugin = require('webpack/lib/container/ModuleFederationPlugin');
+<&- fragments.importsSection() &>
+const packageJson = require('../package.json');
+const appVersion = packageJson.version;
+
+module.exports = ({ serve }) => {
+  return {
+    optimization: {
+      moduleIds: 'named',
+    },
+    plugins: [
+      new ModuleFederationPlugin({
+<%_ if (applicationTypeMicroservice) { _%>
+        name: '<%= lowercaseBaseName %>',
+        filename: 'remoteEntry.js',
+<%_ } _%>
+        shareScope: 'default',
+<&- fragments.moduleFederationSection() &>
+      }),
+<&- fragments.pluginsSection() &>
+    ],
+    output: {
+      publicPath: 'auto',
+    },
+    optimization: {
+      runtimeChunk: false,
+    },
+  };
+};

package/generators/client/templates/react/.eslintrc.json.ejs

@@ -62,6 +62,7 @@
     "@typescript-eslint/explicit-member-accessibility": "off",
     "@typescript-eslint/explicit-function-return-type": "off",
     "@typescript-eslint/no-explicit-any": "off",
+    "@typescript-eslint/no-unsafe-argument": "off",
     "@typescript-eslint/no-unsafe-return": "off",
     "@typescript-eslint/no-unsafe-member-access":"off",
     "@typescript-eslint/no-unsafe-call": "off",