aril 0.0.44 → 0.0.46

package/boot/mfe/src/bootstrap.ts

@@ -0,0 +1,78 @@
+import { provideHttpClient, withInterceptors } from '@angular/common/http';
+import { APP_INITIALIZER, ApplicationConfig, importProvidersFrom } from '@angular/core';
+import { createCustomElement } from '@angular/elements';
+import { createApplication } from '@angular/platform-browser';
+import { provideAnimations } from '@angular/platform-browser/animations';
+import {
+	Routes,
+	provideRouter,
+	withComponentInputBinding,
+	withHashLocation,
+	withViewTransitions
+} from '@angular/router';
+
+import { ConfirmationService, MenuItem, MessageService } from 'primeng/api';
+
+import { KeycloakAngularModule } from 'keycloak-angular';
+
+import { loadApiConfigs, setApiConfigOnMFEMode } from 'aril/boot/config/api';
+import { Apps } from 'aril/boot/config/apps';
+import { getNgZone, loadPlugins } from 'aril/boot/config/plugins';
+import { HttpBackendService, stateMachineInterceptor } from 'aril/http';
+import { i18nFolderName, i18nModule } from 'aril/i18n';
+import { KeycloakManager, authInterceptor } from 'aril/keycloak';
+import { StyleLoaderService } from 'aril/util/loaders';
+
+import { appComponentLoader } from './appComponentLoader';
+import { loadStyles } from './loadStyles';
+
+export var appName: Apps;
+export var menuItems: MenuItem[] = [];
+
+export const boot = (_appName: Apps, _routes: Routes, _menuItems: MenuItem[]) => {
+	if (customElements.get(`app-${_appName}`)) return;
+
+	appName = _appName;
+	menuItems = _menuItems;
+
+	const appBootConfig: ApplicationConfig = {
+		providers: [
+			provideAnimations(),
+			provideHttpClient(withInterceptors([authInterceptor, stateMachineInterceptor])),
+			provideRouter(_routes, withComponentInputBinding(), withHashLocation(), withViewTransitions()),
+			importProvidersFrom(i18nModule, KeycloakAngularModule),
+			getNgZone(),
+			MessageService,
+			ConfirmationService,
+			{
+				provide: APP_INITIALIZER,
+				useFactory: (<any>globalThis).isHostMode ? setApiConfigOnMFEMode : loadApiConfigs,
+				multi: true,
+				deps: [HttpBackendService, KeycloakManager, i18nFolderName]
+			},
+			{
+				provide: APP_INITIALIZER,
+				useFactory: loadPlugins,
+				multi: true,
+				deps: [HttpBackendService]
+			},
+			{
+				provide: APP_INITIALIZER,
+				useFactory: loadStyles,
+				multi: true,
+				deps: [StyleLoaderService, i18nFolderName]
+			},
+			{
+				provide: i18nFolderName,
+				useValue: _appName
+			}
+		]
+	};
+
+	createApplication(appBootConfig).then((appRef) => {
+		appComponentLoader().then((AppComponent) => {
+			const app = createCustomElement(AppComponent, { injector: appRef.injector });
+			customElements.define(`app-${appName}`, app);
+		});
+	});
+};

package/boot/mfe/src/loadStyles.ts

@@ -0,0 +1,19 @@
+import { Apps } from 'aril/boot/config/apps';
+import { StyleLoaderService } from 'aril/util/loaders';
+
+export function loadStyles(styleLoaderService: StyleLoaderService, appName: Apps): () => Promise<any> {
+	const styles = [
+		'layout.css',
+		'ui.common.css',
+		'preloading.css',
+		'primeng.min.css',
+		'theme.light.indigo.css',
+		'dx.fluent.saas.light.css',
+		`assets/${appName}/styles/primeflex/primeflex.min.css`,
+		`assets/${appName}/styles/primeicons/primeicons.css`
+	];
+
+	if ((<any>globalThis).isHostMode) return () => Promise.resolve();
+
+	return () => styleLoaderService.load(styles);
+}

package/boot/ng-package.json

@@ -0,0 +1,6 @@
+{
+	"$schema": "../../../node_modules/ng-packagr/ng-package.schema.json",
+	"lib": {
+		"entryFile": "./index.ts"
+	}
+}

package/http/{index.d.ts → index.ts}

@@ -1,8 +1,13 @@
-export * from './lib/enums';
-export * from './lib/interfaces';
-export * from './src/httpBackend';
-export * from './src/httpClient';
-export * from './src/serviceBase';
-export * from './src/serviceMockBase';
-export * from './src/serviceStateMethods';
-export * from './src/interceptor/state-machine.interceptor';
+/* lib */
+export * from './lib/enums';
+export * from './lib/interfaces';
+
+/* src */
+export * from './src/httpBackend';
+export * from './src/httpClient';
+export * from './src/serviceBase';
+export * from './src/serviceMockBase';
+export * from './src/serviceStateMethods';
+
+/* interceptor */
+export * from './src/interceptor/state-machine.interceptor';

package/http/lib/enums.ts

@@ -0,0 +1,13 @@
+export enum HTTPMethods {
+	GET = 'GET',
+	GETBYPARAMS = 'GETBYPARAMS',
+	POST = 'POST',
+	PUT = 'PUT',
+	DELETE = 'DELETE',
+	DELETEBYPARAMS = 'DELETEBYPARAMS'
+}
+export enum ProxyTypes {
+	Native,
+	ServerSide,
+	ClientSide
+}

package/http/lib/interfaces.ts

@@ -0,0 +1,38 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/* eslint-disable @typescript-eslint/ban-types */
+import { HttpErrorResponse } from '@angular/common/http';
+
+import { ProxyTypes } from './enums';
+
+export interface ServiceCallStates {
+	serviceCalled: boolean;
+	waitingForResponse: boolean;
+	responseIsRecieved: boolean;
+	serviceCallFailed: boolean;
+}
+
+export type ServiceCallStateMap<T> = {
+	[K in keyof T]?: T[K] extends Function ? ServiceCallStates : never;
+};
+
+export class ErrorResponse {
+	error: HttpErrorResponse | undefined;
+
+	constructor(err: HttpErrorResponse | undefined) {
+		this.error = err;
+	}
+}
+
+export class ServiceResponse<T> extends ErrorResponse {
+	request: any;
+	response: T;
+	proxy: ProxyTypes;
+
+	constructor(request: any, response: T, proxy: ProxyTypes) {
+		super(undefined);
+		this.request = request;
+		this.response = response;
+		this.proxy = proxy;
+	}
+}

package/http/ng-package.json

@@ -0,0 +1,6 @@
+{
+	"$schema": "../../../node_modules/ng-packagr/ng-package.schema.json",
+	"lib": {
+		"entryFile": "./index.ts"
+	}
+}

package/http/src/httpBackend.ts

@@ -0,0 +1,12 @@
+import { HttpBackend, HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+
+// WithoutInterceptorHttpClient
+@Injectable({ providedIn: 'root' })
+export class HttpBackendService {
+	public httpClient: HttpClient;
+
+	constructor(handler: HttpBackend) {
+		this.httpClient = new HttpClient(handler);
+	}
+}

package/http/src/httpClient.ts

@@ -0,0 +1,20 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { HttpClient } from '@angular/common/http';
+import { Injector, inject } from '@angular/core';
+
+import { MessageService } from 'primeng/api';
+
+import { TranslocoService } from '@ngneat/transloco';
+
+// import { KeycloakService } from 'keycloak-angular';
+import { ServiceCallStateMap } from '../lib/interfaces';
+
+export abstract class RestClient {
+	private readonly httpClient = inject(HttpClient);
+	private readonly injector = inject(Injector);
+	private readonly messageService = inject(MessageService);
+	private readonly translocoService = inject(TranslocoService);
+	// private readonly keycloak = inject(KeycloakService);
+
+	abstract states: ServiceCallStateMap<any>;
+}

package/http/src/interceptor/state-machine.interceptor.ts

@@ -0,0 +1,9 @@
+import { HttpHandlerFn, HttpInterceptorFn, HttpRequest } from '@angular/common/http';
+
+export const stateMachineInterceptor: HttpInterceptorFn = (req: HttpRequest<unknown>, next: HttpHandlerFn) => {
+	let clone = req;
+	if (req.url.includes('state-machine/v1')) {
+		clone = req.clone({ url: req.url.split('/host/v1').join('') });
+	}
+	return next(clone);
+};

package/http/src/serviceBase.ts

@@ -0,0 +1,91 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { HttpClient, HttpErrorResponse, HttpParams } from '@angular/common/http';
+import { runInInjectionContext } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+
+import { Observable, of } from 'rxjs';
+import { catchError, map, tap } from 'rxjs/operators';
+
+import { API_CONFIGS } from 'aril/boot/config/api';
+
+import { HTTPMethods, ProxyTypes } from '../lib/enums';
+import { ErrorResponse, ServiceCallStateMap, ServiceResponse } from '../lib/interfaces';
+import { getRequest } from './serviceRequest';
+import { callState, errorState, successState } from './serviceStateMethods';
+
+export function ServiceCall(
+	httpMethod: HTTPMethods,
+	proxy: ProxyTypes,
+	serviceURL: string,
+	message?: { success?: string; error?: string },
+	remoteAPI?: string,
+	isMockAPI = false
+): MethodDecorator {
+	return function (serviceClass: object, serviceName: string | symbol, descriptor: PropertyDescriptor) {
+		// const originalFunction = descriptor.value;
+
+		descriptor.value = function (...args: any[]) {
+			return runInInjectionContext((<any>this).injector, () => {
+				const httpClient: HttpClient = (<any>this).httpClient;
+
+				let api = '';
+				if (isMockAPI) api = <string>remoteAPI;
+				else if (remoteAPI) {
+					const url = new URL(API_CONFIGS.api);
+					api = url.origin + '/' + remoteAPI;
+				} else api = API_CONFIGS.api;
+
+				const endPoint = api + '/' + serviceURL;
+				const request = getRequest(httpMethod, args);
+				const states: ServiceCallStateMap<any> = (<any>this).states;
+
+				callState(states, serviceName);
+
+				let observable: Observable<any> = new Observable<any>();
+
+				switch (httpMethod) {
+					case HTTPMethods.GET:
+						let getReq = args.length ? '/' + args[0] : '';
+						observable = httpClient.get<any>(endPoint + getReq, { responseType: 'json' });
+						break;
+					case HTTPMethods.GETBYPARAMS:
+						observable = httpClient.get<any>(endPoint, { params: request as HttpParams, responseType: 'json' });
+						break;
+					case HTTPMethods.POST:
+						observable = httpClient.post<any>(endPoint, args[0], { responseType: 'json' });
+						break;
+					case HTTPMethods.PUT:
+						observable = httpClient.put<any>(endPoint + '/' + args[0], request, { responseType: 'json' });
+						break;
+					case HTTPMethods.DELETE:
+						observable = httpClient.delete<any>(endPoint + '/' + args[0], { responseType: 'json' });
+						break;
+					case HTTPMethods.DELETEBYPARAMS:
+						observable = httpClient.delete<any>(endPoint, { params: request as HttpParams, responseType: 'json' });
+						break;
+				}
+
+				observable = observable.pipe(
+					map((response) => new ServiceResponse(request, response, proxy)),
+					tap((resp) =>
+						successState(
+							states,
+							serviceName,
+							(<any>this).translocoService,
+							(<any>this).messageService,
+							message,
+							resp.response
+						)
+					),
+					catchError((error: HttpErrorResponse) => {
+						errorState(states, serviceName, error, (<any>this).translocoService, (<any>this).messageService, message);
+						return of(new ErrorResponse(error));
+					}),
+					takeUntilDestroyed()
+				);
+
+				return observable;
+			});
+		};
+	};
+}

package/http/src/serviceMockBase.ts

@@ -0,0 +1,12 @@
+import { HTTPMethods, ProxyTypes } from '../lib/enums';
+import { ServiceCall } from './serviceBase';
+
+export function ServiceCallMock(
+	httpMethod: HTTPMethods,
+	proxy: ProxyTypes,
+	serviceURL: string,
+	mockAPI: string,
+	message?: { success?: string; error?: string; useDefault: boolean }
+) {
+	return ServiceCall(httpMethod, proxy, serviceURL, message, mockAPI, true);
+}

package/http/src/serviceRequest.ts

@@ -0,0 +1,26 @@
+import { HttpParams } from '@angular/common/http';
+
+import { Interfaces } from 'aril/util/lib';
+
+import { HTTPMethods } from '../lib/enums';
+
+export function getRequest(httpMethod: HTTPMethods, args: any[]): HttpParams | Interfaces.MapStringAny | undefined {
+	if (!args.length) return undefined;
+
+	switch (httpMethod) {
+		case HTTPMethods.PUT:
+			return args[1];
+		case HTTPMethods.GETBYPARAMS:
+		case HTTPMethods.DELETEBYPARAMS:
+			const dto = args[0];
+			let queryParams = new HttpParams();
+
+			for (const [key, value] of Object.entries(dto)) {
+				queryParams = queryParams.append(key, value as any);
+			}
+
+			return queryParams;
+		default:
+			return args[0];
+	}
+}

package/http/src/serviceStateMethods.ts

@@ -0,0 +1,155 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { HttpErrorResponse } from '@angular/common/http';
+
+import { MessageService } from 'primeng/api';
+
+import { TranslocoService } from '@ngneat/transloco';
+
+import { ServiceCallStateMap } from '../lib/interfaces';
+
+export const callState = (states: ServiceCallStateMap<any>, serviceName: any): void => {
+	states[serviceName] = {
+		serviceCalled: true,
+		waitingForResponse: true,
+		responseIsRecieved: false,
+		serviceCallFailed: false
+	};
+};
+
+export const successState = (
+	states: ServiceCallStateMap<any>,
+	serviceName: any,
+	translocoService: TranslocoService,
+	messageService: MessageService,
+	message?: { success?: string; error?: string },
+	response?: any
+): void => {
+	states[serviceName] = {
+		serviceCalled: true,
+		waitingForResponse: false,
+		responseIsRecieved: true,
+		serviceCallFailed: false
+	};
+
+	if (message?.success) {
+		messageService.add({
+			key: 'toast-root',
+			severity: 'success',
+			summary: getTranslatedMessage(<string>message.success, translocoService, response)
+		});
+	}
+};
+
+export const errorState = (
+	states: ServiceCallStateMap<any>,
+	serviceName: any,
+	error: HttpErrorResponse,
+	translocoService: TranslocoService,
+	messageService: MessageService,
+	message?: { success?: string; error?: string, display?:string }
+): void => {
+	states[serviceName] = {
+		serviceCalled: true,
+		waitingForResponse: false,
+		responseIsRecieved: true,
+		serviceCallFailed: true
+	};
+
+	let httpError: string;
+
+	switch (error.status) {
+		case 400:
+			httpError = 'Bad Request';
+			break;
+		case 401:
+			httpError = 'Unauthorized';
+			break;
+		case 403:
+			httpError = 'Forbidden';
+			break;
+		case 404:
+			httpError = 'Not Found';
+			break;
+		case 405:
+			httpError = 'Method Not Allowed';
+			break;
+		case 406:
+			httpError = 'Not Acceptable';
+			break;
+		case 408:
+			httpError = 'Request Timeout';
+			break;
+		case 409:
+			httpError = 'Conflict';
+			break;
+		case 500:
+			httpError = 'Internal Server Error';
+			break;
+		case 501:
+			httpError = 'Not Implemented';
+			break;
+		case 502:
+			httpError = 'Bad Gateway';
+			break;
+		case 503:
+			httpError = 'Service Unavailable';
+			break;
+		case 504:
+			httpError = 'Gateway Timeout';
+			break;
+		case 505:
+			httpError = 'HTTP Version Not Supported';
+			break;
+		case 511:
+			httpError = 'Network Authentication Required';
+			break;
+		default:
+			httpError = error?.error?.message;
+			break;
+	}
+
+	messageService.add({
+		key: 'toast-root',
+		severity: 'error',
+		summary: httpError,
+		detail: error?.error?.display ?  error?.error?.display : error?.error?.message
+	});
+
+	if (message?.error) {
+		messageService.add({
+			key: 'toast-root',
+			severity: 'error',
+			summary: error?.error?.display ? error?.error?.display : getTranslatedMessage(<string>message.error, translocoService)
+		});
+	}
+
+};
+
+const getTranslatedMessage = (messageCode: string, translocoService: TranslocoService, response?: any): string => {
+	const translateObject = translocoService.getTranslation().get(translocoService.getActiveLang());
+	let translatedMessage = translateObject?.[messageCode] ?? messageCode;
+
+	const paramStartSymbol = '{{';
+	const paramEndSymbol = '}}';
+
+	if (response && translatedMessage.includes(paramStartSymbol) && translatedMessage.includes(paramEndSymbol)) {
+		do {
+			let paramStartIndex = translatedMessage.indexOf(paramStartSymbol);
+			let paramEndIndex = translatedMessage.indexOf(paramEndSymbol);
+			let paramKey = translatedMessage.slice(paramStartIndex + paramStartSymbol.length, paramEndIndex);
+
+			// Splitting the key to get nested object values
+			let paramKeyList = paramKey.split('.');
+			let paramValue;
+
+			for (let key of paramKeyList) {
+				paramValue = paramValue ? paramValue[key] : response[key];
+			}
+
+			let replacePattern = `${paramStartSymbol}${paramKey}${paramEndSymbol}`;
+			translatedMessage = translatedMessage.replace(replacePattern, paramValue);
+		} while (translatedMessage.includes(paramStartSymbol));
+	}
+
+	return translatedMessage;
+};

package/i18n/{index.d.ts → index.ts}

@@ -1,5 +1,5 @@
-export * from './src/loader';
-export * from './src/provideI18n';
-export * from './src/provideScope';
-export * from './src/folder-name-token';
-export * from './src/i18n.module';
+export * from './src/loader';
+export * from './src/provideI18n';
+export * from './src/provideScope';
+export * from './src/folder-name-token';
+export * from './src/i18n.module';

package/i18n/ng-package.json

@@ -0,0 +1,6 @@
+{
+	"$schema": "../../../node_modules/ng-packagr/ng-package.schema.json",
+	"lib": {
+		"entryFile": "./index.ts"
+	}
+}

package/i18n/src/folder-name-token.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+
+export const i18nFolderName = new InjectionToken<string>('i18nFolderName');

package/i18n/src/i18n.module.ts

@@ -0,0 +1,11 @@
+import { NgModule } from '@angular/core';
+
+import { TranslocoModule } from '@ngneat/transloco';
+
+import { i18nProvider } from './provideI18n';
+
+@NgModule({
+	exports: [TranslocoModule],
+	providers: [i18nProvider()]
+})
+export class i18nModule {}

package/i18n/src/loader.ts

@@ -0,0 +1,16 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable, inject } from '@angular/core';
+
+import { Translation, TranslocoLoader } from '@ngneat/transloco';
+
+import { i18nFolderName } from './folder-name-token';
+
+@Injectable({ providedIn: 'root' })
+export class TranslocoHttpLoader implements TranslocoLoader {
+	private http = inject(HttpClient);
+	private folderUrl = inject(i18nFolderName);
+
+	getTranslation(lang: string) {
+		return this.http.get<Translation>(`./assets/${this.folderUrl}/i18n/${lang}.json`);
+	}
+}

package/i18n/src/provideI18n.ts

@@ -0,0 +1,18 @@
+import { EnvironmentProviders, isDevMode } from '@angular/core';
+
+import { provideTransloco } from '@ngneat/transloco';
+
+import { TranslocoHttpLoader } from './loader';
+
+export const i18nProvider = (): EnvironmentProviders[] => {
+	return provideTransloco({
+		config: {
+			availableLangs: ['tr', 'en'],
+			defaultLang: 'tr',
+			fallbackLang: 'tr',
+			reRenderOnLangChange: true,
+			prodMode: !isDevMode()
+		},
+		loader: TranslocoHttpLoader
+	});
+};

package/i18n/src/provideScope.ts

@@ -0,0 +1,20 @@
+import { provideTranslocoScope } from '@ngneat/transloco';
+
+const languages = ['tr', 'en'];
+
+/**
+ * @param loader `(lang: string) => import(`./i18n/${lang}.json`)` to create a relative import to the correct dir
+ */
+function i18nLoaderFactory(loader: (lang: string) => Promise<any>) {
+	return languages.reduce((acc: any, lang) => {
+		acc[lang] = () => loader(lang);
+		return acc;
+	}, {});
+}
+
+export const providei18nScope = (scopeName: string, loader: (lang: string) => Promise<any>) => {
+	return provideTranslocoScope({
+		scope: scopeName,
+		loader: i18nLoaderFactory(loader)
+	});
+};

package/keycloak/{index.d.ts → index.ts}

@@ -1,3 +1,3 @@
-export * from './src/keycloak.manager';
-export * from './src/auth.interceptor';
-export * from './src/auth.guard';
+export * from './src/keycloak.manager';
+export * from './src/auth.interceptor';
+export * from './src/auth.guard';

package/keycloak/ng-package.json

@@ -0,0 +1,6 @@
+{
+	"$schema": "../../../node_modules/ng-packagr/ng-package.schema.json",
+	"lib": {
+		"entryFile": "./index.ts"
+	}
+}

package/keycloak/src/auth.guard.ts

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, Router, RouterStateSnapshot } from '@angular/router';
+
+import { KeycloakAuthGuard, KeycloakService } from 'keycloak-angular';
+
+@Injectable({
+	providedIn: 'root'
+})
+export class AuthGuard extends KeycloakAuthGuard {
+	constructor(
+		protected override readonly router: Router,
+		protected readonly keycloak: KeycloakService
+	) {
+		super(router, keycloak);
+	}
+
+	public async isAccessAllowed(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
+		if (!this.authenticated) {
+			await this.keycloak.login({
+				redirectUri: window.location.origin + state.url
+			});
+		}
+
+		const requiredRoles = route.data['roles'];
+
+		if (!Array.isArray(requiredRoles) || requiredRoles.length === 0) {
+			return true;
+		}
+
+		const authorized = requiredRoles.every((role) => this.roles.includes(role));
+
+		if (!authorized) {
+			console.error('User not authorized to access this route');
+			return false;
+		} else return true;
+	}
+}