@techextensor/tab-core-utility 2.1.5 → 2.1.7

package/src/lib/tab-core-utility/auth/auth.service.spec.ts

@@ -0,0 +1,167 @@
+import { TestBed } from '@angular/core/testing';
+import {
+  HttpClientTestingModule,
+  HttpTestingController,
+} from '@angular/common/http/testing';
+import { AuthService } from './auth.service';
+import { ApiService } from '../core/http-client/api.service';
+import { UserResponse } from '../app/interfaces/user.interface';
+import { ApiResponse } from '../app/interfaces/common-api.interface';
+import { LocalStorageService } from './local-storage.service';
+
+describe('AuthService', () => {
+  let authService: AuthService;
+  let httpMock: HttpTestingController;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+      providers: [AuthService, ApiService, LocalStorageService],
+    });
+    authService = TestBed.inject(AuthService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => {
+    httpMock.verify();
+  });
+
+  it('should be created', () => {
+    expect(authService).toBeTruthy();
+  });
+
+  it('should fetch user details', () => {
+    const mockUrl = 'mockUrl';
+    const mockResponse: UserResponse = {
+      /* mock user response object */
+      user: {
+        id: '1',
+        email: 'john.doe@example.com',
+        token: 'example_token',
+        username: 'john_doe',
+        bio: 'Sample biography',
+        image: 'https://example.com/profile.jpg',
+      },
+    };
+
+    authService.user(mockUrl).subscribe((response: UserResponse) => {
+      expect(response).toEqual(mockResponse);
+    });
+
+    const request = httpMock.expectOne(mockUrl);
+    expect(request.request.method).toBe('GET');
+    request.flush(mockResponse);
+  });
+
+  it('should sign in with given credentials', () => {
+    const mockUrl = 'mockUrl';
+    const mockCredentials = {
+      /* mock login credentials */
+      email: 'john.doe@example.com',
+      password: '123456',
+    };
+    const mockResponse: UserResponse = {
+      /* mock user response object */
+      user: {
+        id: '1',
+        email: 'john.doe@example.com',
+        token: 'example_token',
+        username: 'john_doe',
+        bio: 'Sample biography',
+        image: 'https://example.com/profile.jpg',
+      },
+    };
+
+    authService
+      .signIn(mockUrl, mockCredentials)
+      .subscribe((response: UserResponse) => {
+        expect(response).toEqual(mockResponse);
+      });
+
+    const request = httpMock.expectOne(mockUrl);
+    expect(request.request.method).toBe('POST');
+    expect(request.request.body).toEqual(mockCredentials);
+    request.flush(mockResponse);
+  });
+
+  it('should register new user with provided credentials', () => {
+    const mockUrl = 'mockUrl';
+    const mockCredentials = {
+      /* mock login credentials */
+      username: 'john.doe',
+      email: 'john.doe@example.com',
+      password: '123456',
+    };
+    const mockResponse: UserResponse = {
+      /* mock user response object */
+      user: {
+        id: '1',
+        email: 'john.doe@example.com',
+        token: 'example_token',
+        username: 'john_doe',
+        bio: 'Sample biography',
+        image: 'https://example.com/profile.jpg',
+      },
+    };
+
+    authService
+      .register(mockUrl, mockCredentials)
+      .subscribe((response: UserResponse) => {
+        expect(response).toEqual(mockResponse);
+      });
+
+    const request = httpMock.expectOne(mockUrl);
+    expect(request.request.method).toBe('POST');
+    expect(request.request.body).toEqual(mockCredentials);
+    request.flush(mockResponse);
+  });
+
+  it('should forgot password in with given credentials', () => {
+    const mockUrl = 'mockUrl';
+    const email = { email: 'test@example.com' };
+    const response: ApiResponse = {
+      requestId: '123456',
+      isSuccess: true,
+      result: [],
+      errors: [],
+    };
+    authService
+      .forgotPassword(mockUrl, email)
+      .subscribe((response: ApiResponse) => {
+        expect(response).toEqual(response);
+      });
+
+    const request = httpMock.expectOne(mockUrl);
+    expect(request.request.method).toBe('POST');
+    expect(request.request.body).toEqual(email);
+    request.flush(response);
+  });
+
+  it('should reset password in with given credentials', () => {
+    const mockUrl = 'mockUrl';
+    const password = { password: '123456' };
+    const response: ApiResponse = {
+      requestId: '123456',
+      isSuccess: true,
+      result: [],
+      errors: [],
+    };
+    authService
+      .resetPassword(mockUrl, password)
+      .subscribe((response: ApiResponse) => {
+        expect(response).toEqual(response);
+      });
+
+    const request = httpMock.expectOne(mockUrl);
+    expect(request.request.method).toBe('POST');
+    expect(request.request.body).toEqual(password);
+    request.flush(response);
+  });
+
+  it('should logout current session', () => {
+    spyOn(localStorage, 'removeItem');
+    const key = 'testKey';
+    authService.logout(key);
+    expect(localStorage.removeItem(key)).toHaveBeenCalled();
+  });
+});

package/src/lib/tab-core-utility/auth/auth.service.ts

@@ -0,0 +1,91 @@
+import { Injectable, inject } from '@angular/core';
+import { Observable } from 'rxjs';
+import {
+  ForgotPasswordUserRequest,
+  LoginUserRequest,
+  NewUserRequest,
+  ResetPasswordUserRequest,
+} from '../app/interfaces/auth.interface';
+import { UserResponse } from '../app/interfaces/user.interface';
+import { ApiService } from '../core/http-client/api.service';
+import { ApiResponse } from '../app/interfaces/common-api.interface';
+import { LocalStorageService } from './local-storage.service';
+
+@Injectable({ providedIn: 'root' })
+export class AuthService {
+  /**
+   * Injecting required services
+   */
+  private readonly apiService = inject(ApiService);
+  private readonly localStorageService = inject(LocalStorageService);
+
+  // -----------------------------------------------------------------------------------------------------
+  // @ Public methods
+  // -----------------------------------------------------------------------------------------------------
+
+  /**
+   * Fetch user details from the database
+   *
+   * @param endPointName - The End Point Name to fetch user details
+   * @returns Observable<UserResponse> - An observable of UserResponse
+   */
+  user(endPointName: string): Observable<UserResponse> {
+    return this.apiService.get<UserResponse>(endPointName);
+  }
+
+  /**
+   * Sign in with provided credentials
+   *
+   * @param endPointName - The End Point Name to sign in
+   * @param credentials - The login credentials
+   * @returns Observable<UserResponse> - An observable of UserResponse
+   */
+  signIn(endPointName: string, credentials: LoginUserRequest): Observable<UserResponse> {
+    return this.apiService.post<UserResponse, LoginUserRequest>(
+      endPointName,
+      credentials
+    );
+  }
+
+  /**
+   * Register a new user
+   *
+   * @param endPointName - The End Point Name to register a new user
+   * @param credentials - The new user's credentials
+   * @returns Observable<UserResponse> - An observable of UserResponse
+   */
+  register(endPointName: string, credentials: NewUserRequest): Observable<UserResponse> {
+    return this.apiService.post<UserResponse, NewUserRequest>(endPointName, credentials);
+  }
+
+  /**
+   * Forgot password
+   * @param endPointName - The End Point Name of API
+   * @param email - The email of user
+   */
+  forgotPassword(
+    endPointName: string,
+    email: ForgotPasswordUserRequest
+  ): Observable<ApiResponse> {
+    return this.apiService.post(endPointName, email);
+  }
+
+  /**
+   * Reset password
+   * @param endPointName - The End Point Name of API
+   * @param password - The password of user
+   */
+  resetPassword(
+    endPointName: string,
+    password: ResetPasswordUserRequest
+  ): Observable<ApiResponse> {
+    return this.apiService.post(endPointName, password);
+  }
+
+  /**
+   * Logout current session
+   */
+  logout(key: string) {
+    this.localStorageService.removeLocalStorage(key);
+  }
+}

package/src/lib/tab-core-utility/auth/idb-storage.service.ts

@@ -0,0 +1,77 @@
+import { Injectable } from '@angular/core';
+import { openDB, IDBPDatabase, DBSchema } from 'idb';
+
+interface MyDB extends DBSchema {
+    myObjectStore: {
+        key: string;
+        value: { key: string; data: string };
+    };
+}
+
+@Injectable({ providedIn: 'root' })
+export class IdbService {
+    private readonly dbName = 'TabDatabase';
+    private readonly dbVersion = 1;
+    private dbPromise: Promise<IDBPDatabase<MyDB>>;
+
+    constructor() {
+        this.dbPromise = openDB<MyDB>(this.dbName, this.dbVersion, {
+            upgrade(db) {
+                if (!db.objectStoreNames.contains('myObjectStore')) {
+                    db.createObjectStore('myObjectStore', { keyPath: 'key' });
+                }
+            },
+        });
+    }
+
+    async setItem(key: string, data: any): Promise<void> {
+        try {
+            if (data) {
+                await this.setItemIndexedDb(key, data);
+            }
+        } catch (error) {
+            throw new Error('Error storing data: ' + error);
+        }
+    }
+
+    private async setItemIndexedDb(key: string, data: any): Promise<void> {
+        const db = await this.dbPromise;
+        const tx = db.transaction('myObjectStore', 'readwrite');
+        const store = tx.objectStore('myObjectStore');
+        await store.put({ key, data });
+        await tx.done;
+    }
+
+    async getItem(key: string): Promise<any> {
+        try {
+            const result = await this.getItemIndexedDb(key);
+            return result?.data;
+        } catch (error) {
+            throw new Error('Error retrieving data: ' + error);
+        }
+    }
+
+    private async getItemIndexedDb(key: string): Promise<any> {
+        const db = await this.dbPromise;
+        const tx = db.transaction('myObjectStore', 'readonly');
+        const store = tx.objectStore('myObjectStore');
+        const result = await store.get(key);
+        await tx.done;
+        return result;
+    }
+
+    async clearIndexedDB(): Promise<void> {
+        try {
+            const db = await this.dbPromise;
+            const tx = db.transaction('myObjectStore', 'readwrite');
+            const store = tx.objectStore('myObjectStore');
+            await store.clear();
+            await tx.done;
+        } catch (error) {
+            throw new Error('Error clearing IndexedDB: ' + error)
+        }
+    }
+}
+
+
+

package/src/lib/tab-core-utility/auth/local-storage.service.spec.ts

@@ -0,0 +1,47 @@
+import { TestBed, inject } from '@angular/core/testing';
+import { LocalStorageService } from './local-storage.service';
+
+describe('LocalStorageService', () => {
+  let localStorageService: LocalStorageService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [LocalStorageService],
+    });
+  });
+
+  it('should be created', () => {
+    inject([LocalStorageService], (service: LocalStorageService) => {
+      expect(service).toBeTruthy();
+    });
+  });
+
+  it('should set data in local storage', () => {
+    const key = 'testKey';
+    const data = { name: 'John Doe', age: 30 };
+    localStorageService.setLocalStorage(key, data);
+    expect(localStorage.getItem(key)).toEqual(JSON.stringify(data));
+  });
+
+  it('should get data from local storage', () => {
+    const key = 'testKey';
+    const data = { name: 'Jane Smith', age: 25 };
+    localStorage.setItem(key, JSON.stringify(data));
+    const retrievedData = localStorageService.getLocalStorage(key);
+    expect(retrievedData).toEqual(data);
+  });
+
+  it('should return null when getting non-existent data from local storage', () => {
+    const key = 'nonExistentKey';
+    const retrievedData = localStorageService.getLocalStorage(key);
+    expect(retrievedData).toBeNull();
+  });
+
+  it('should remove data from local storage', () => {
+    const key = 'testKey';
+    const data = { city: 'New York', population: 8000000 };
+    localStorage.setItem(key, JSON.stringify(data));
+    localStorageService.removeLocalStorage(key);
+    expect(localStorage.getItem(key)).toBeNull();
+  });
+});

package/src/lib/tab-core-utility/auth/local-storage.service.ts

@@ -0,0 +1,46 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Injectable } from '@angular/core';
+
+@Injectable({ providedIn: 'root' })
+export class LocalStorageService {
+  // -----------------------------------------------------------------------------------------------------
+  // @ Public methods
+  // -----------------------------------------------------------------------------------------------------
+
+  /**
+   * Set data in local storage
+   * @param key - Key to store the data
+   * @param data - Data to be stored
+   */
+  setLocalStorage = (key: string, data: any): void => {
+    // localStorage.setItem(key, JSON.stringify(data));
+    if (typeof data === 'string') {
+      localStorage.setItem(key, data);
+    } else {
+      localStorage.setItem(key, JSON.stringify(data));
+    }
+  };
+
+  /**
+   * Get data from local storage
+   * @param key - Key to retrieve the data
+   * @returns The data stored in local storage
+   */
+  getLocalStorage = (key: string): any => {
+    const data = localStorage.getItem(key);
+    return data ? data: null;
+    // if (typeof data === 'string') {
+    //   return data ? data: null;
+    // } else {
+    //   return data ? JSON.parse(data) : null;
+    // }
+  };
+
+  /**
+   * Remove data from local storage
+   * @param key - Key of the data to be removed
+   */
+  removeLocalStorage = (key: string): void => {
+    localStorage.removeItem(key);
+  };
+}

package/src/lib/tab-core-utility/auth/session-storage.service.spec.ts

@@ -0,0 +1,47 @@
+import { TestBed, inject } from '@angular/core/testing';
+import { SessionStorageService } from './session-storage.service';
+
+describe('SessionStorageService', () => {
+  let sessionStorageService: SessionStorageService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [SessionStorageService],
+    });
+  });
+
+  it('should be created', () => {
+    inject([SessionStorageService], (service: SessionStorageService) => {
+      expect(service).toBeTruthy();
+    });
+  });
+
+  it('should set data in session storage', () => {
+    const key = 'testKey';
+    const data = { name: 'John Doe', age: 30 };
+    sessionStorageService.setSessionStorage(key, data);
+    expect(sessionStorage.getItem(key)).toEqual(JSON.stringify(data));
+  });
+
+  it('should get data from session storage', () => {
+    const key = 'testKey';
+    const data = { name: 'Jane Smith', age: 25 };
+    sessionStorage.setItem(key, JSON.stringify(data));
+    const retrievedData = sessionStorageService.getSessionStorage(key);
+    expect(retrievedData).toEqual(data);
+  });
+
+  it('should return null when getting non-existent data from session storage', () => {
+    const key = 'nonExistentKey';
+    const retrievedData = sessionStorageService.getSessionStorage(key);
+    expect(retrievedData).toBeNull();
+  });
+
+  it('should remove data from session storage', () => {
+    const key = 'testKey';
+    const data = { city: 'New York', population: 8000000 };
+    sessionStorage.setItem(key, JSON.stringify(data));
+    sessionStorageService.removeSessionStorage(key);
+    expect(sessionStorage.getItem(key)).toBeNull();
+  });
+});

package/src/lib/tab-core-utility/auth/session-storage.service.ts

@@ -0,0 +1,46 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Injectable } from '@angular/core';
+
+@Injectable({ providedIn: 'root' })
+export class SessionStorageService {
+  // -----------------------------------------------------------------------------------------------------
+  // @ Public methods
+  // -----------------------------------------------------------------------------------------------------
+
+  /**
+   * Set data in session storage
+   * @param key - Key to store the data
+   * @param data - Data to be stored
+   */
+  setSessionStorage = (key: string, data: any): void => {
+    // sessionStorage.setItem(key, JSON.stringify(data));
+    if (typeof data === 'string') {
+      sessionStorage.setItem(key, data);
+    } else {
+      sessionStorage.setItem(key, JSON.stringify(data));
+    }
+  };
+
+  /**
+   * Get data from session storage
+   * @param key - Key to retrieve the data
+   * @returns The data stored in session storage
+   */
+  getSessionStorage = (key: string): any => {
+    const data = sessionStorage.getItem(key);
+    return data ? data: null;
+    // if (typeof data === 'string') {
+    //   return data ? data: null;
+    // } else {
+    //   return data ? JSON.parse(data) : null;
+    // }
+  };
+
+  /**
+   * Remove data from session storage
+   * @param key - Key of the data to be removed
+   */
+  removeSessionStorage = (key: string): void => {
+    sessionStorage.removeItem(key);
+  };
+}

package/src/lib/tab-core-utility/core/error-handler/error-handler-interceptor.service.ts

@@ -0,0 +1,32 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { HttpErrorResponse, HttpEvent, HttpHandlerFn, HttpRequest } from '@angular/common/http';
+import { inject } from '@angular/core';
+import { Observable, throwError } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import { ErrorHandlerStore } from './error-handler.store';
+
+export const errorHandlingInterceptor = (
+  request: HttpRequest<any>,
+  next: HttpHandlerFn,
+): Observable<HttpEvent<any>> => {
+  const errorHandlerStore = inject(ErrorHandlerStore);
+
+  return next(request).pipe(
+    catchError((error) => {
+      if (error instanceof HttpErrorResponse) {
+        switch (error.status) {
+          case 401:
+            errorHandlerStore.handleError401(error);
+            break;
+          case 404:
+            errorHandlerStore.handleError404(error);
+            break;
+          default:
+            throwError(() => error);
+            break;
+        }
+      }
+      return throwError(() => error);
+    }),
+  );
+};

package/src/lib/tab-core-utility/core/error-handler/error-handler.store.spec.ts

@@ -0,0 +1,16 @@
+import { inject, TestBed } from '@angular/core/testing';
+
+import { ErrorHandlerStore } from './error-handler.store';
+import { provideMockStore } from '@ngrx/store/testing';
+
+describe('ErrorHandlerStore', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [ErrorHandlerStore, provideMockStore({})],
+    });
+  });
+
+  it('should be created', inject([ErrorHandlerStore], (service: typeof ErrorHandlerStore) => {
+    expect(service).toBeTruthy();
+  }));
+});

package/src/lib/tab-core-utility/core/error-handler/error-handler.store.ts

@@ -0,0 +1,26 @@
+import { signalStore, withState, withMethods, patchState } from '@ngrx/signals';
+import { inject } from '@angular/core';
+import { Router } from '@angular/router';
+import { ErrorHandlerState, errorHandlerInitialState } from './models/error-handler.state';
+import { HttpErrorResponse } from '@angular/common/http';
+
+export const ErrorHandlerStore = signalStore(
+  { providedIn: 'root' },
+  withState<ErrorHandlerState>(errorHandlerInitialState),
+  withMethods((store, router = inject(Router)) => ({
+    handleError401: (error: HttpErrorResponse) => {
+      patchState(store, {
+        code: error.status,
+        message: error.message,
+      });
+      router.navigate(['/login']);
+    },
+    handleError404: (error: HttpErrorResponse) => {
+      patchState(store, {
+        code: error.status,
+        message: error.message,
+      });
+      router.navigate(['/']);
+    },
+  })),
+);

package/src/lib/tab-core-utility/core/error-handler/models/error-handler.state.ts

@@ -0,0 +1,9 @@
+export interface ErrorHandlerState {
+  code: number;
+  message: string | undefined;
+}
+
+export const errorHandlerInitialState: ErrorHandlerState = {
+  message: undefined,
+  code: -1,
+};

package/src/lib/tab-core-utility/core/http-client/api-url.token.ts

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

package/src/lib/tab-core-utility/core/http-client/api.service.spec.ts

@@ -0,0 +1,18 @@
+import { TestBed, inject } from '@angular/core/testing';
+import { HttpClientTestingModule } from '@angular/common/http/testing';
+
+import { ApiService } from './api.service';
+import { API_URL } from './api-url.token';
+
+describe('ApiService', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+      providers: [ApiService, { provide: API_URL, useValue: 'api_url' }],
+    });
+  });
+
+  it('should be created', inject([ApiService], (service: ApiService) => {
+    expect(service).toBeTruthy();
+  }));
+});