generator-jhipster 7.9.0 → 7.9.3

package/generators/client/templates/angular/src/main/webapp/app/shared/filter/filter.model.spec.ts.ejs

@@ -1,40 +1,242 @@
 import { convertToParamMap, ParamMap, Params } from '@angular/router';
-import { FilterOptions, IFilterOptions } from './filter.model';
+import { FilterOptions, FilterOption } from './filter.model';
 
 describe('FilterModel Tests', () => {
-  const oneValidParam: Params = {
-    test: 'blub',
-    'filter[hello.in]': 'world',
-    'filter[invalid': 'invalid',
-    filter_invalid2: 'invalid',
-  };
+  describe('FilterOption', () => {
+    let filterOption: FilterOption;
 
-  const noValidParam: Params = {
-    test: 'blub',
-    'filter[invalid': 'invalid',
-    filter_invalid2: 'invalid',
-  };
+    beforeEach(() => {
+      filterOption = new FilterOption('foo', ['bar', 'bar2']);
+    });
 
-  it('should parse from Params if there are any', () => {
-    const filters: IFilterOptions = new FilterOptions();
+    it('nameAsQueryParam returns query key', () => {
+      expect(filterOption.nameAsQueryParam()).toEqual('filter[foo]');
+    });
 
-    const paramMap: ParamMap = convertToParamMap(oneValidParam);
+    describe('addValue', () => {
+      it('adds multiples unique values and returns true', () => {
+        const ret = filterOption.addValue('bar2', 'bar3', 'bar4');
+        expect(filterOption.values).toMatchObject(['bar', 'bar2', 'bar3', 'bar4']);
+        expect(ret).toBe(true);
+      });
+      it("doesn't adds duplicated values and return false", () => {
+        const ret = filterOption.addValue('bar', 'bar2');
+        expect(filterOption.values).toMatchObject(['bar', 'bar2']);
+        expect(ret).toBe(false);
+      });
+    });
 
-    filters.initializeFromParams(paramMap);
+    describe('removeValue', () => {
+      it('removes the exiting value and return true', () => {
+        const ret = filterOption.removeValue('bar');
+        expect(filterOption.values).toMatchObject(['bar2']);
+        expect(ret).toBe(true);
+      });
+      it("doesn't removes the value and return false", () => {
+        const ret = filterOption.removeValue('foo');
+        expect(filterOption.values).toMatchObject(['bar', 'bar2']);
+        expect(ret).toBe(false);
+      });
+    });
 
-    expect(filters.hasAnyFilterSet()).toBeTruthy();
-
-    expect(filters.filterOptions[0].name).toBe('hello.in');
-    expect(filters.filterOptions[0].value).toBe('world');
+    describe('equals', () => {
+      it('returns true to matching options', () => {
+        const otherFilterOption = new FilterOption(filterOption.name, filterOption.values.concat());
+        expect(filterOption.equals(otherFilterOption)).toBe(true);
+        expect(otherFilterOption.equals(filterOption)).toBe(true);
+      });
+      it('returns false to different name', () => {
+        const otherFilterOption = new FilterOption('bar', filterOption.values.concat());
+        expect(filterOption.equals(otherFilterOption)).toBe(false);
+        expect(otherFilterOption.equals(filterOption)).toBe(false);
+      });
+      it('returns false to different values', () => {
+        const otherFilterOption = new FilterOption('bar', []);
+        expect(filterOption.equals(otherFilterOption)).toBe(false);
+        expect(otherFilterOption.equals(filterOption)).toBe(false);
+      });
+    });
   });
 
-  it('should parse from Params and have none if there are none', () => {
-    const filters: IFilterOptions = new FilterOptions();
+  describe('FilterOptions', () => {
+    describe('hasAnyFilterSet', () => {
+      it('with empty options returns false', () => {
+        const filters = new FilterOptions();
+        expect(filters.hasAnyFilterSet()).toBe(false);
+      });
+      it('with options and empty values returns false', () => {
+        const filters = new FilterOptions([new FilterOption('foo'), new FilterOption('bar')]);
+        expect(filters.hasAnyFilterSet()).toBe(false);
+      });
+      it('with option and value returns true', () => {
+        const filters = new FilterOptions([new FilterOption('foo', ['bar'])]);
+        expect(filters.hasAnyFilterSet()).toBe(true);
+      });
+    });
+
+    describe('clear', () => {
+      it("removes empty filters and dosn't emit next element", () => {
+        const filters = new FilterOptions([new FilterOption('foo'), new FilterOption('bar')]);
+        jest.spyOn(filters.filterChanges, 'next');
+
+        filters.clear();
+
+        expect(filters.filterChanges.next).not.toBeCalled();
+        expect(filters.filterOptions).toMatchObject([]);
+      });
+      it('removes empty filters and emits next element', () => {
+        const filters = new FilterOptions([new FilterOption('foo', ['existingFoo1']), new FilterOption('bar')]);
+        jest.spyOn(filters.filterChanges, 'next');
+
+        filters.clear();
+
+        expect(filters.filterChanges.next).toHaveBeenCalledTimes(1);
+        expect(filters.filterOptions).toMatchObject([]);
+      });
+    });
+
+    describe('addFilter', () => {
+      it('adds a non existing FilterOption, returns true and emit next element', () => {
+        const filters = new FilterOptions([new FilterOption('foo', ['existingFoo1', 'existingFoo2']), new FilterOption('bar')]);
+        jest.spyOn(filters.filterChanges, 'next');
+
+        const result = filters.addFilter('addedFilter', 'addedValue');
+
+        expect(result).toBe(true);
+        expect(filters.filterChanges.next).toHaveBeenCalledTimes(1);
+        expect(filters.filterOptions).toMatchObject([
+          { name: 'foo', values: ['existingFoo1', 'existingFoo2'] },
+          { name: 'addedFilter', values: ['addedValue'] },
+        ]);
+      });
+      it('adds a non existing value to FilterOption, returns true and emit next element', () => {
+        const filters = new FilterOptions([new FilterOption('foo', ['existingFoo1', 'existingFoo2']), new FilterOption('bar')]);
+        jest.spyOn(filters.filterChanges, 'next');
+
+        const result = filters.addFilter('foo', 'addedValue1', 'addedValue2');
+
+        expect(result).toBe(true);
+        expect(filters.filterChanges.next).toHaveBeenCalledTimes(1);
+        expect(filters.filterOptions).toMatchObject([
+          { name: 'foo', values: ['existingFoo1', 'existingFoo2', 'addedValue1', 'addedValue2'] },
+        ]);
+      });
+      it("doesn't add FilterOption values already added, returns false and doesn't emit next element", () => {
+        const filters = new FilterOptions([new FilterOption('foo', ['existingFoo1', 'existingFoo2']), new FilterOption('bar')]);
+        jest.spyOn(filters.filterChanges, 'next');
+
+        const result = filters.addFilter('foo', 'existingFoo1', 'existingFoo2');
+
+        expect(result).toBe(false);
+        expect(filters.filterChanges.next).not.toBeCalled();
+        expect(filters.filterOptions).toMatchObject([{ name: 'foo', values: ['existingFoo1', 'existingFoo2'] }]);
+      });
+    });
+
+    describe('removeFilter', () => {
+      it('removes an existing FilterOptions and returns true', () => {
+        const filters = new FilterOptions([new FilterOption('foo', ['existingFoo1', 'existingFoo2']), new FilterOption('bar')]);
+        jest.spyOn(filters.filterChanges, 'next');
+
+        const result = filters.removeFilter('foo', 'existingFoo1');
+
+        expect(result).toBe(true);
+        expect(filters.filterChanges.next).toHaveBeenCalledTimes(1);
+        expect(filters.filterOptions).toMatchObject([{ name: 'foo', values: ['existingFoo2'] }]);
+      });
+      it("doesn't remove a non existing FilterOptions values returns false", () => {
+        const filters = new FilterOptions([new FilterOption('foo', ['existingFoo1', 'existingFoo2']), new FilterOption('bar')]);
+        jest.spyOn(filters.filterChanges, 'next');
+
+        const result = filters.removeFilter('foo', 'nonExisting1');
+
+        expect(result).toBe(false);
+        expect(filters.filterChanges.next).not.toBeCalled();
+        expect(filters.filterOptions).toMatchObject([{ name: 'foo', values: ['existingFoo1', 'existingFoo2'] }]);
+      });
+      it("doesn't remove a non existing FilterOptions returns false", () => {
+        const filters = new FilterOptions([new FilterOption('foo', ['existingFoo1', 'existingFoo2']), new FilterOption('bar')]);
+        jest.spyOn(filters.filterChanges, 'next');
+
+        const result = filters.removeFilter('nonExisting', 'nonExisting1');
+
+        expect(result).toBe(false);
+        expect(filters.filterChanges.next).not.toBeCalled();
+        expect(filters.filterOptions).toMatchObject([{ name: 'foo', values: ['existingFoo1', 'existingFoo2'] }]);
+      });
+    });
+
+    describe('initializeFromParams', () => {
+      const oneValidParam: Params = {
+        test: 'blub',
+        'filter[hello.in]': 'world',
+        'filter[invalid': 'invalid',
+        filter_invalid2: 'invalid',
+      };
+
+      const noValidParam: Params = {
+        test: 'blub',
+        'filter[invalid': 'invalid',
+        filter_invalid2: 'invalid',
+      };
+
+      const paramWithTwoValues: Params = {
+        'filter[hello.in]': ['world', 'world2'],
+      };
+
+      const paramWithTwoKeys: Params = {
+        'filter[hello.in]': ['world', 'world2'],
+        'filter[hello.notIn]': ['world3', 'world4'],
+      };
+
+      it('should parse from Params if there are any and not emit next element', () => {
+        const filters: FilterOptions = new FilterOptions([new FilterOption('foo', ['bar'])]);
+        jest.spyOn(filters.filterChanges, 'next');
+        const paramMap: ParamMap = convertToParamMap(oneValidParam);
+
+        filters.initializeFromParams(paramMap);
+
+        expect(filters.filterChanges.next).not.toHaveBeenCalled();
+        expect(filters.filterOptions).toMatchObject([{ name: 'hello.in', values: ['world'] }]);
+      });
+
+      it('should parse from Params and have none if there are none', () => {
+        const filters: FilterOptions = new FilterOptions();
+        const paramMap: ParamMap = convertToParamMap(noValidParam);
+        jest.spyOn(filters.filterChanges, 'next');
+
+        filters.initializeFromParams(paramMap);
+
+        expect(filters.filterChanges.next).not.toHaveBeenCalled();
+        expect(filters.filterOptions).toMatchObject([]);
+      });
+
+      it('should parse from Params and have a parameter with 2 values and one aditional value', () => {
+        const filters: FilterOptions = new FilterOptions([new FilterOption('hello.in', ['world'])]);
+        jest.spyOn(filters.filterChanges, 'next');
+
+        const paramMap: ParamMap = convertToParamMap(paramWithTwoValues);
+
+        filters.initializeFromParams(paramMap);
+
+        expect(filters.filterChanges.next).not.toHaveBeenCalled();
+        expect(filters.filterOptions).toMatchObject([{ name: 'hello.in', values: ['world', 'world2'] }]);
+      });
+
+      it('should parse from Params and have a parameter with 2 keys', () => {
+        const filters: FilterOptions = new FilterOptions();
+        jest.spyOn(filters.filterChanges, 'next');
 
-    const paramMap: ParamMap = convertToParamMap(noValidParam);
+        const paramMap: ParamMap = convertToParamMap(paramWithTwoKeys);
 
-    filters.initializeFromParams(paramMap);
+        filters.initializeFromParams(paramMap);
 
-    expect(filters.hasAnyFilterSet()).toBeFalsy();
+        expect(filters.filterChanges.next).not.toHaveBeenCalled();
+        expect(filters.filterOptions).toMatchObject([
+          { name: 'hello.in', values: ['world', 'world2'] },
+          { name: 'hello.notIn', values: ['world3', 'world4'] },
+        ]);
+      });
+    });
   });
 });

package/generators/client/templates/angular/src/main/webapp/app/shared/filter/filter.model.ts.ejs

@@ -1,80 +1,97 @@
 import { ParamMap } from '@angular/router';
+import { Subject } from 'rxjs';
 
 export interface IFilterOptions {
-  containsSameOption(option: IFilterOption): unknown;
-  filterOptions: IFilterOption[];
+  readonly filterChanges: Subject<FilterOption[]>;
+  get filterOptions(): IFilterOption[];
   hasAnyFilterSet(): boolean;
-  clear(): void;
-  removeByName(name: string): void;
+  clear(): boolean;
   initializeFromParams(params: ParamMap): boolean;
-  equals(other: IFilterOptions): boolean;
-  clone(): IFilterOptions;
+  addFilter(name: string, ...values: string[]): boolean;
+  removeFilter(name: string, value: string): boolean;
 }
 
 export interface IFilterOption {
   name: string;
-  value: string | null;
-  isSet(): boolean;
+  values: string[];
   nameAsQueryParam(): string;
 }
 
-export interface IFilterableComponent {
-  clearFilter(filterName: string): void;
-  clearAllFilters(): void;
-}
-
 export class FilterOption implements IFilterOption {
-  constructor(public name: string, public value: string | null) {}
+  constructor(public name: string, public values: string[] = []) {
+    this.values = [...new Set(values)];
+  }
 
   nameAsQueryParam(): string {
     return 'filter[' + this.name + ']';
   }
 
   isSet(): boolean {
-    return this.value != null && this.value.length > 0;
+    return this.values.length > 0;
   }
-}
 
-export class FilterOptions implements IFilterOptions {
-  filterOptions: IFilterOption[] = [];
-
-  hasAnyFilterSet(): boolean {
-    return this.filterOptions.length > 0 && this.filterOptions.every(e => e.isSet());
+  addValue(...values: string[]): boolean {
+    const missingValues = values.filter(value => value && !this.values.includes(value));
+    if (missingValues.length > 0) {
+      this.values.push(...missingValues);
+      return true;
+    }
+    return false;
   }
 
-  clear(): void {
-    this.filterOptions = [];
-  }
+  removeValue(value: string): boolean {
+    const indexOf = this.values.indexOf(value);
+    if (indexOf === -1) {
+      return false;
+    }
 
-  add(option: IFilterOption): void {
-    this.filterOptions.push(option);
+    this.values.splice(indexOf, 1);
+    return true;
   }
 
-  removeByName(name: string): void {
-    this.filterOptions = this.filterOptions.filter(option => option.name !== name);
+  clone(): FilterOption {
+    return new FilterOption(this.name, this.values.concat());
   }
 
-  equals(other: IFilterOptions): boolean {
+  equals(other: IFilterOption): boolean {
     return (
-      this.filterOptions.every(thisOption => other.containsSameOption(thisOption)) &&
-      other.filterOptions.every(otherOption => this.containsSameOption(otherOption))
+      this.name === other.name &&
+      this.values.length === other.values.length &&
+      this.values.every(thisValue => other.values.includes(thisValue)) &&
+      other.values.every(otherValue => this.values.includes(otherValue))
     );
   }
+}
 
-  clone(): IFilterOptions {
-    const newObject: FilterOptions = new FilterOptions();
+export class FilterOptions implements IFilterOptions {
+  readonly filterChanges: Subject<FilterOption[]> = new Subject();
+  private _filterOptions: FilterOption[];
 
-    this.filterOptions.forEach(option => {
-      newObject.add(new FilterOption(option.name, option.value));
-    });
+  constructor(filterOptions: FilterOption[] = []) {
+    this._filterOptions = filterOptions;
+  }
 
-    return newObject;
+  get filterOptions(): FilterOption[] {
+    return this._filterOptions.filter(option => option.isSet());
+  }
+
+  hasAnyFilterSet(): boolean {
+    return this._filterOptions.some(e => e.isSet());
+  }
+
+  clear(): boolean {
+    const hasFields = this.hasAnyFilterSet();
+    this._filterOptions = [];
+    if (hasFields) {
+      this.changed();
+    }
+    return hasFields;
   }
 
   initializeFromParams(params: ParamMap): boolean {
-    const oldFilters: IFilterOptions = this.clone();
+    const oldFilters: FilterOptions = this.clone();
 
-    this.clear();
+    this._filterOptions = [];
 
     const filterRegex = /filter\[(.+)\]/;
     params.keys
@@ -82,14 +99,58 @@ export class FilterOptions implements IFilterOptions {
       .forEach(matchingParam => {
         const matches = matchingParam.match(filterRegex);
         if (matches && matches.length > 1) {
-          this.add(new FilterOption(matches[1], params.get(matchingParam)));
+          this.getFilterOptionByName(matches[1], true).addValue(...params.getAll(matchingParam));
         }
       });
 
-    return !oldFilters.equals(this);
+    if (oldFilters.equals(this)) {
+      return false;
+    }
+    return true;
+  }
+
+  addFilter(name: string, ...values: string[]): boolean {
+    if (this.getFilterOptionByName(name, true).addValue(...values)) {
+      this.changed();
+      return true;
+    }
+    return false;
   }
 
-  containsSameOption(optionToSearch: IFilterOption): boolean {
-    return this.filterOptions.some(option => option.name === optionToSearch.name && option.value === optionToSearch.value);
+  removeFilter(name: string, value: string): boolean {
+    if (this.getFilterOptionByName(name)?.removeValue(value)) {
+      this.changed();
+      return true;
+    }
+    return false;
+  }
+
+  protected changed(): void {
+    this.filterChanges.next(this.filterOptions.map(option => option.clone()));
+  }
+
+  protected equals(other: FilterOptions): boolean {
+    const thisFilters = this.filterOptions;
+    const otherFilters = other.filterOptions;
+    if (thisFilters.length !== otherFilters.length) {
+      return false;
+    }
+    return thisFilters.every(option => other.getFilterOptionByName(option.name)?.equals(option));
+  }
+
+  protected clone(): FilterOptions {
+    return new FilterOptions(this.filterOptions.map(option => new FilterOption(option.name, option.values.concat())));
+  }
+
+  protected getFilterOptionByName(name: string, add: true): FilterOption;
+  protected getFilterOptionByName(name: string, add: false): FilterOption | null;
+  protected getFilterOptionByName(name: string): FilterOption | null;
+  protected getFilterOptionByName(name: string, add = false): FilterOption | null {
+    const addOption = (option: FilterOption): FilterOption => {
+      this._filterOptions.push(option);
+      return option;
+    };
+
+    return this._filterOptions.find(thisOption => thisOption.name === name) ?? (add ? addOption(new FilterOption(name)) : null);
   }
 }

package/generators/client/templates/angular/src/main/webapp/content/scss/global.scss.ejs

@@ -182,6 +182,14 @@ Custom alerts for notification
   }
 }
 
+/* ==========================================================================
+entity list page css
+========================================================================== */
+
+.table-entities thead th .d-flex > * {
+  margin: auto 0;
+}
+
 /* ==========================================================================
 entity detail page css
 ========================================================================== */

package/generators/client/templates/angular/tsconfig.json.ejs

@@ -17,7 +17,6 @@
  limitations under the License.
 -%>
 {
-  "include": [],
   "compilerOptions": {
     "baseUrl": "<%= CLIENT_MAIN_SRC_DIR %>",
     "outDir": "./<%= DIST_DIR %>",

package/generators/client/templates/angular/tsconfig.spec.json.ejs

@@ -18,10 +18,9 @@
 -%>
 {
   "extends": "./tsconfig.json",
+  "include": ["<%= MAIN_SRC_DIR %>**/*.ts"],
   "compilerOptions": {
     "outDir": "<%= BUILD_DIR %>out-tsc/spec",
     "types": ["jest", "node"]
-  },
-  "files": ["<%= MAIN_SRC_DIR %>polyfills.ts"],
-  "include": ["<%= MAIN_SRC_DIR %>**/*.ts"]
+  }
 }

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

@@ -33,9 +33,6 @@ module.exports = (config, options, targetOptions) => {
   <%_ } _%>
           './entity-navbar-items': 'app/entities/entity-navbar-items.ts',
           './entity-routing': 'app/entities/entity-routing.module.ts',
-  <%_ for (entity of Object.values(this.configOptions.sharedEntities || {}).filter(e => e.microserviceName)) { _%>
-          './<%= entity.entityFileName %>': 'app/entities/<%= entity.entityFolderName %>/<%= entity.entityFileName %>.module.ts',
-  <%_ } _%>
         },
 <%_ } _%>
 <%_ if (applicationTypeGateway) { _%>

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

@@ -3,14 +3,14 @@
     "@cypress/code-coverage": "3.10.0",
     "babel-loader": "8.2.5",
     "babel-plugin-istanbul": "6.1.1",
-    "cypress": "10.3.1",
+    "cypress": "10.7.0",
     "cypress-audit": "1.1.0",
     "eslint-plugin-cypress": "2.12.1",
-    "lighthouse": "9.6.4",
+    "lighthouse": "9.6.6",
     "nyc": "15.1.0",
-    "swagger-ui-dist": "4.13.0"
+    "swagger-ui-dist": "4.14.0"
   },
   "dependencies": {
-    "dayjs": "1.11.4"
+    "dayjs": "1.11.5"
   }
 }

package/generators/client/templates/common/src/main/webapp/swagger-ui/index.html.ejs

@@ -74,7 +74,7 @@
 
         const baseUrl = '/v3/api-docs';
         let urls;
-<%_ if (!applicationTypeMonolith && serviceDiscoveryType) { _%>
+<%_ if (!applicationTypeMonolith && serviceDiscoveryAny) { _%>
 
         try {
           const response = await axios.get('/management/health/discoveryComposite', axiosConfig);

package/generators/client/templates/react/jest.conf.js.ejs

@@ -20,9 +20,9 @@ module.exports = {
   }),
   reporters: [
     'default',
-    [ 'jest-junit', { outputDirectory: './<%= BUILD_DIR %>test-results/', outputName: 'TESTS-results-jest.xml' } ]
+    ['jest-junit', { outputDirectory: './<%= BUILD_DIR %>test-results/', outputName: 'TESTS-results-jest.xml' }],
+    ['jest-sonar', { outputDirectory: './<%= BUILD_DIR %>test-results/jest', outputName: 'TESTS-results-sonar.xml' }],
   ],
-  testResultsProcessor: 'jest-sonar-reporter',
   testPathIgnorePatterns: [
     '<rootDir>/node_modules/'
   ],