fix(core): fix ngc issues and clean-up code in stark-core. Integrate …

…AppMetadata in Starter

packages/stark-core/karma.conf.typescript.ci.js

@@ -22,12 +22,9 @@ defaultKarmaCIConfig(configExtractor);
 let starkCoreSpecificConfiguration = loadedConfiguration;
 
 // change the path of the report so that Coveralls takes the right path to the source files
-starkCoreSpecificConfiguration.coverageIstanbulReporter = Object.assign(
-	starkCoreSpecificConfiguration.coverageIstanbulReporter,
-	{
-		dir: helpers.root("reports/coverage/packages"),
-	}
-);
+starkCoreSpecificConfiguration.coverageIstanbulReporter = Object.assign(starkCoreSpecificConfiguration.coverageIstanbulReporter, {
+	dir: helpers.root("reports/coverage/packages")
+});
 
 // export the configuration function that karma expects and simply return the stark configuration
 module.exports = config => {

packages/stark-core/src/configuration/entities/application/app-config.entity.ts

@@ -6,8 +6,10 @@ import { StarkApplicationConfig } from "./app-config.entity.intf";
 import { StarkBackend, StarkBackendImpl } from "../../../http/entities/backend/index";
 import { stringMap } from "../../../serialization/index";
 import { StarkValidationErrorsUtil } from "../../../util/index";
-// FIXME Implement the following decorators as before
-// import {StarkMapIsValid, StarkMapNotEmpty} from "../../../validation/decorators";
+// FIXME: cannot import both validation decorators from the barrel due to an issue with angular-compiler
+// see: https://github.com/angular/angular/issues/20931
+import { StarkMapIsValid } from "../../../validation/decorators/map-is-valid/map-is-valid.validator.decorator";
+import { StarkMapNotEmpty } from "../../../validation/decorators/map-not-empty/map-not-empty.validator.decorator";
 
 export class StarkApplicationConfigImpl implements StarkApplicationConfig {
 	@IsDefined()
@@ -115,9 +117,8 @@ export class StarkApplicationConfigImpl implements StarkApplicationConfig {
 	@autoserialize
 	public publicApp: boolean;
 
-	//FIXME Import StarkMapIsValid & StarkMapNotEmpty  from validation/decorators
-	// @StarkMapNotEmpty()
-	// @StarkMapIsValid()
+	@StarkMapNotEmpty()
+	@StarkMapIsValid()
 	@autoserializeAs(stringMap(StarkBackendImpl)) // using custom serialization type (stringMap) to handle ES6 Maps
 	public backends: Map<string, StarkBackend> = new Map<string, StarkBackend>();
 

packages/stark-core/src/configuration/entities/language/language.entity.ts

@@ -3,14 +3,15 @@
 import { IsNotEmpty, IsString, Matches } from "class-validator";
 import { autoserialize } from "cerialize";
 import { StarkLanguage } from "./language.entity.intf";
-
-// import {StarkIsSupportedLanguage} from "../../validation/decorators/is-supported-language";
+// FIXME: cannot import both validation decorator from the barrel due to an issue with angular-compiler
+// see: https://github.com/angular/angular/issues/20931
+import { StarkIsSupportedLanguage } from "../../../validation/decorators/is-supported-language/is-supported-language.validator.decorator";
 
 export class StarkLanguageImpl implements StarkLanguage {
 	@IsNotEmpty()
 	@IsString()
 	@Matches(/^[a-z]{2}-[A-Z]{2}$/)
-	// @StarkIsSupportedLanguage()  // FIXME: add Stark validator decorators
+	@StarkIsSupportedLanguage()
 	@autoserialize
 	public isoCode: string;
 

packages/stark-core/src/http/services/http.service.spec.ts

@@ -1192,9 +1192,9 @@ describe("Service: StarkHttpService", () => {
 					item: mockResourceWithoutEtag,
 					serializer: mockResourceSerializer
 				};
-				const result: Observable<any> = starkHttpService.executeSingleItemRequest(request);
+				const result: ErrorObservable = <ErrorObservable>starkHttpService.executeSingleItemRequest(request);
 				expect(result instanceof ErrorObservable).toBe(true);
-				expect((<ErrorObservable>result).error).toContain("Unknown request type");
+				expect(result.error).toContain("Unknown request type");
 			});
 		});
 	});
@@ -2376,9 +2376,9 @@ describe("Service: StarkHttpService", () => {
 					item: undefined,
 					serializer: mockResourceSerializer
 				};
-				const result: Observable<any> = starkHttpService.executeCollectionRequest(request);
+				const result: ErrorObservable = <ErrorObservable>starkHttpService.executeCollectionRequest(request);
 				expect(result instanceof ErrorObservable).toBe(true);
-				expect((<ErrorObservable>result).error).toContain("Unknown request type");
+				expect(result.error).toContain("Unknown request type");
 			});
 		});
 	});

packages/stark-core/src/logging/services/logging.service.spec.ts

@@ -19,7 +19,7 @@ import { StarkError, StarkErrorImpl } from "../../common/index";
 
 describe("Service: StarkLoggingService", () => {
 	let appConfig: StarkApplicationConfig;
-	let mockStore: Store<any>;
+	let mockStore: Store<StarkCoreApplicationState>;
 	// let mockXSRFService: StarkXSRFService;
 	let loggingService: LoggingServiceHelper;
 	const loggingBackend: StarkBackend = {
@@ -78,9 +78,7 @@ describe("Service: StarkLoggingService", () => {
 			appConfig.loggingFlushDisabled = false;
 			appConfig.backends.delete("logging");
 
-			expect(() => new LoggingServiceHelper(mockStore, appConfig /*, mockXSRFService*/)).toThrowError(
-				"Backend logging is undefined."
-			);
+			expect(() => new LoggingServiceHelper(mockStore, appConfig /*, mockXSRFService*/)).toThrowError(/backend/);
 		});
 
 		it("should throw an error in case the logging flushing is enabled but the loggingFlushPersistSize option is not greater than 0", () => {

packages/stark-core/src/routing/services/routing.service.spec.ts

@@ -18,6 +18,7 @@ import CallInfo = jasmine.CallInfo;
 import { StarkRoutingActionTypes } from "../actions/index";
 import Spy = jasmine.Spy;
 import { MockStarkLoggingService } from "../../logging/testing/logging.mock";
+import { StarkCoreApplicationState } from "../../common/store/starkCoreApplicationState";
 
 @Component({ selector: "test-home", template: "HOME" })
 export class HomeComponent {}
@@ -31,7 +32,7 @@ describe("Service: StarkRoutingService", () => {
 
 	let routingService: StarkRoutingServiceImpl;
 	let mockLogger: StarkLoggingService;
-	const mockStore: Store<any> = jasmine.createSpyObj("storeSpy", ["dispatch"]);
+	const mockStore: Store<StarkCoreApplicationState> = jasmine.createSpyObj("storeSpy", ["dispatch"]);
 	const appConfig: Partial<StarkApplicationConfig> = {
 		sessionTimeout: 123,
 		sessionTimeoutWarningPeriod: 13,

packages/stark-core/src/session/services/session.service.spec.ts

@@ -46,7 +46,7 @@ import { starkSessionExpiredStateName } from "../../common/routes/index";
 import { StarkCoreApplicationState } from "../../common/store/index";
 
 describe("Service: StarkSessionService", () => {
-	let mockStore: Store<any>;
+	let mockStore: Store<StarkCoreApplicationState>;
 	let appConfig: StarkApplicationConfig;
 	let mockSession: StarkSession;
 	let mockUser: Partial<StarkUser>;
@@ -336,7 +336,7 @@ describe("Service: StarkSessionService", () => {
 
 		it("should call the destroySession() method only when the logout HTTP request has returned a response (either success or error)", () => {
 			spyOn(sessionService, "destroySession");
-			const logoutHttpResponse$: Subject<any> = new Subject();
+			const logoutHttpResponse$: Subject<string> = new Subject();
 			const sendLogoutRequestSpy: Spy = spyOn(sessionService, "sendLogoutRequest").and.returnValue(logoutHttpResponse$);
 
 			sessionService.logout();

packages/stark-core/src/session/services/session.service.ts

@@ -310,8 +310,7 @@ export class StarkSessionServiceImpl implements StarkSessionService {
 		});
 		// }
 
-		// FIXME Should we create an interface instead of using any ?
-		const pingRequest: HttpRequest<any> = new HttpRequest("GET", <string>this.appConfig.keepAliveUrl, {
+		const pingRequest: HttpRequest<void> = new HttpRequest("GET", <string>this.appConfig.keepAliveUrl, {
 			headers: pingRequestHeaders
 		});
 

packages/stark-core/src/user/services/user.service.spec.ts

@@ -36,19 +36,21 @@ import { StarkHttpStatusCodes } from "../../http/enumerators/index";
 import { StarkSessionService } from "../../session/services/index";
 import { HttpErrorResponse } from "@angular/common/http";
 import { StarkHttpErrorImpl } from "../../http";
+import { StarkMockData } from "../../configuration/entities/mock-data/index";
+import { StarkCoreApplicationState } from "../../common/store/starkCoreApplicationState";
 
 interface StarkUserWithCustomData extends Pick<StarkUser, "uuid" | "username" | "roles"> {
 	[prop: string]: any;
 }
 
 describe("Service: StarkUserService", () => {
 	let userService: StarkUserService;
-	let mockStore: Store<any>;
+	let mockStore: Store<StarkCoreApplicationState>;
 	let mockUserRepository: StarkUserRepository;
 	let mockLogger: StarkLoggingService;
 	let mockSessionService: StarkSessionService;
 
-	let mockData: any;
+	let mockData: StarkMockData;
 	let mockUsers: StarkUserWithCustomData[];
 	let mockUserCustomData: { [prop: string]: any };
 	let mockUserCustomData2: { [prop: string]: any };

packages/stark-core/src/validation/decorators/is-bban/is-bban.validator.decorator.ts

@@ -36,7 +36,6 @@ class StarkIsBBANConstraint implements ValidatorConstraintInterface {
  * @param property
  * @param validationOptions
  * @returns Function
- * @constructor
  */
 export function StarkIsBBAN(property: string, validationOptions?: ValidationOptions): Function {
 	return (object: object, propertyName: string): void => {

packages/stark-core/src/validation/decorators/is-bic/is-bic.validator.decorator.ts

@@ -26,7 +26,6 @@ class StarkIsBICConstraint implements ValidatorConstraintInterface {
  * Validator decorator that uses the StarkIsBIC validator constraint
  * @param validationOptions
  * @returns Function
- * @constructor
  */
 export function StarkIsBIC(validationOptions?: ValidationOptions): Function {
 	return (object: object, propertyName: string): void => {

packages/stark-core/src/validation/decorators/is-company-number/is-company-number.validator.decorator.ts

@@ -11,7 +11,7 @@ import { starkIsCompanyNumberValidatorName } from "../../validators/is-company-n
  * Validates that the Company Number number provided is valid
  */
 @ValidatorConstraint({ name: starkIsCompanyNumberValidatorName, async: false })
-export class StarkIsCompanyNumberConstraint implements ValidatorConstraintInterface {
+class StarkIsCompanyNumberConstraint implements ValidatorConstraintInterface {
 	public validate(companyNumber: string): boolean {
 		const validator: StarkValidator = getFromContainer<StarkValidatorImpl>(StarkValidatorImpl);
 		return validator.starkIsCompanyNumber(companyNumber);
@@ -26,7 +26,6 @@ export class StarkIsCompanyNumberConstraint implements ValidatorConstraintInterf
  * Validator decorator that uses the StarkIsCompanyNumber validator constraint
  * @param validationOptions
  * @returns Function
- * @constructor
  */
 export function StarkIsCompanyNumber(validationOptions?: ValidationOptions): Function {
 	return (object: object, propertyName: string): void => {

packages/stark-core/src/validation/decorators/is-establishment-unit-number/is-establishment-unit-number.validator.decorator.ts

@@ -27,7 +27,6 @@ class StarkIsEstablishmentUnitNumberConstraint implements ValidatorConstraintInt
  * Validator decorator that uses the StarkIsIsEstablishmentUnitNumber validator constraint
  * @param validationOptions
  * @returns Function
- * @constructor
  */
 export function StarkIsEstablishmentUnitNumber(validationOptions?: ValidationOptions): Function {
 	return (object: object, propertyName: string): void => {

packages/stark-core/src/validation/decorators/is-iban/is-iban.validator.decorator.ts

@@ -26,7 +26,6 @@ class StarkIsIBANConstraint implements ValidatorConstraintInterface {
  * Validator decorator that uses the StarkIsIBAN validator constraint
  * @param validationOptions
  * @returns Function
- * @constructor
  */
 export function StarkIsIBAN(validationOptions?: ValidationOptions): Function {
 	return (object: object, propertyName: string): void => {

packages/stark-core/src/validation/decorators/is-isin/is-isin.validator.decorator.ts

@@ -27,7 +27,6 @@ class StarkIsISINConstraint implements ValidatorConstraintInterface {
  * Validator decorator that uses the StarkIsISIN validator constraint
  * @param validationOptions
  * @returns Function
- * @constructor
  */
 export function StarkIsISIN(validationOptions?: ValidationOptions): Function {
 	return (object: object, propertyName: string): void => {

packages/stark-core/src/validation/decorators/is-kbo/is-kbo.validator.decorator.ts

@@ -27,7 +27,6 @@ class StarkIsKBOConstraint implements ValidatorConstraintInterface {
  * Validator decorator that uses the StarkIsKBO validator constraint
  * @param validationOptions
  * @returns Function
- * @constructor
  */
 export function StarkIsKBO(validationOptions?: ValidationOptions): Function {
 	return (object: object, propertyName: string): void => {

packages/stark-core/src/validation/decorators/is-nin/is-nin.validator.decorator.ts

@@ -36,7 +36,6 @@ class StarkIsNINConstraint implements ValidatorConstraintInterface {
  * @param property
  * @param validationOptions
  * @returns Function
- * @constructor
  */
 export function StarkIsNIN(property: string, validationOptions?: ValidationOptions): Function {
 	return (object: object, propertyName: string): void => {

packages/stark-core/src/validation/decorators/is-supported-language/is-supported-language.validator.decorator.ts

@@ -26,7 +26,6 @@ class StarkIsSupportedLanguageConstraint implements ValidatorConstraintInterface
  * Validator decorator that uses the StarkIsSupportedLanguage validator constraint
  * @param validationOptions
  * @returns Function
- * @constructor
  */
 export function StarkIsSupportedLanguage(validationOptions?: ValidationOptions): Function {
 	return (object: object, propertyName: string): void => {

packages/stark-core/src/validation/decorators/map-is-valid/map-is-valid.validator.decorator.ts

@@ -59,7 +59,6 @@ class StarkMapIsValidConstraint implements ValidatorConstraintInterface {
  * Validator decorator that uses the StarkMapIsValid validator constraint
  * @param validationOptions
  * @returns Function
- * @constructor
  */
 export function StarkMapIsValid(validationOptions?: ValidationOptions): Function {
 	return (object: object, propertyName: string): void => {

packages/stark-core/src/validation/decorators/map-not-empty/map-not-empty.validator.decorator.ts

@@ -4,7 +4,7 @@ import { ValidatorConstraint, ValidatorConstraintInterface, ValidationOptions, r
 
 import { StarkValidatorImpl } from "../../validator";
 import { StarkValidator } from "../../validator.intf";
-import { starkMapNotEmptyValidatorName } from "../../validators/map-not-empty";
+import { starkMapNotEmptyValidatorName } from "../../validators/map-not-empty/index";
 
 /**
  * StarkMapNotEmpty validator constraint
@@ -26,7 +26,6 @@ class StarkMapNotEmptyConstraint implements ValidatorConstraintInterface {
  * Validator decorator that uses the StarkMapNotEmpty validator constraint
  * @param validationOptions
  * @returns Function
- * @constructor
  */
 export function StarkMapNotEmpty(validationOptions?: ValidationOptions): Function {
 	return (object: object, propertyName: string): void => {

starter/src/app/app.module.ts

@@ -2,16 +2,22 @@ import { NgModule, NgModuleFactoryLoader, SystemJsNgModuleLoader } from "@angula
 import { BrowserModule } from "@angular/platform-browser";
 import { FormsModule } from "@angular/forms";
 import { UIRouterModule } from "@uirouter/angular";
-import { StoreModule, MetaReducer, ActionReducerMap, ActionReducer } from "@ngrx/store";
+import { validateSync } from "class-validator";
+import { ActionReducer, ActionReducerMap, MetaReducer, StoreModule } from "@ngrx/store";
 import { storeFreeze } from "ngrx-store-freeze";
 import { storeLogger } from "ngrx-store-logger";
 import { BrowserAnimationsModule } from "@angular/platform-browser/animations";
+
 import {
-	StarkHttpModule,
-	StarkLoggingModule,
 	STARK_APP_CONFIG,
+	STARK_APP_METADATA,
 	StarkApplicationConfig,
-	StarkApplicationConfigImpl
+	StarkApplicationConfigImpl,
+	StarkApplicationMetadata,
+	StarkApplicationMetadataImpl,
+	StarkHttpModule,
+	StarkLoggingModule,
+	StarkValidationErrorsUtil
 } from "@nationalbankbelgium/stark-core";
 import { routerConfigFn } from "./router.config";
 import { Deserialize } from "cerialize";
@@ -52,9 +58,22 @@ export function starkAppConfigFactory(): StarkApplicationConfig {
 	applicationConfig.debugLoggingEnabled = true; //DEVELOPMENT;
 	applicationConfig.routerLoggingEnabled = true; //DEVELOPMENT;
 
+	StarkValidationErrorsUtil.throwOnError(validateSync(applicationConfig), STARK_APP_CONFIG + " constant is not valid.");
+
 	return applicationConfig;
 }
 
+// TODO: where to put this factory function?
+export function starkAppMetadataFactory(): StarkApplicationMetadata {
+	const metadata: any = require("../stark-app-metadata.json");
+
+	const applicationMetadata: StarkApplicationMetadata = Deserialize(metadata, StarkApplicationMetadataImpl);
+
+	StarkValidationErrorsUtil.throwOnError(validateSync(applicationMetadata), STARK_APP_METADATA + " constant is not valid.");
+
+	return applicationMetadata;
+}
+
 // Application Redux State
 export interface State {
 	// reducer interfaces
@@ -110,7 +129,8 @@ export const metaReducers: MetaReducer<State>[] = !environment.production ? [log
 		environment.ENV_PROVIDERS,
 		APP_PROVIDERS,
 		{ provide: NgModuleFactoryLoader, useClass: SystemJsNgModuleLoader }, // needed for ui-router
-		{ provide: STARK_APP_CONFIG, useFactory: starkAppConfigFactory }
+		{ provide: STARK_APP_CONFIG, useFactory: starkAppConfigFactory },
+		{ provide: STARK_APP_METADATA, useFactory: starkAppMetadataFactory }
 	]
 })
 export class AppModule {}